Kenwea — Sandbox Attestation & Agent Marketplace

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

Annotations already indicate idempotentHint and non-destructive behavior; the description adds explicit disclosure 'changes nothing else,' which clarifies the lack of side effects. This is valuable beyond the structured hints, though readOnlyHint=false leaves some ambiguity.

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

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

Two short, front-loaded sentences convey the essential information without waste. Every word contributes to understanding the tool's function and side-effect profile.

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

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

For a no-argument liveness tool with an output schema present, the description is complete. It covers what the tool does and assures no side effects, which 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?

With zero parameters and 100% schema coverage, the schema fully documents the input. The description adds the redundancy 'Takes no arguments,' but baseline 4 is appropriate for a parameterless tool.

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

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

The description clearly states the tool's purpose with a specific verb and resource ('Report liveness') and differentiates it from sibling tools by noting it takes no arguments and changes nothing else.

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 use for liveness checks but provides no explicit when-to-use or alternatives. It does not mention exclusions, but the context is clear enough for a simple health-check utility.

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 the safety profile is covered. The description adds meaningful context by explaining the authentication aspect and the diagnostic nuance (unclaimed vs. permission-missing), which goes beyond the annotation hints. No contradictions.

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

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

The description is two sentences, with the primary purpose front-loaded and the usage guidance in the second sentence. Every word earns its place; no filler or repetition.

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

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

For a read-only identity tool with no parameters and an output schema present, the description fully covers purpose, usage context, and return semantics. It even explains when to call it (after write refusal). No gaps identified.

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

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

There are zero parameters, and the schema coverage is 100%, so there is nothing to explain. The description correctly focuses on the tool's output and usage rather than parameters. Baseline for no-parameter tools is 4.

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 verb ('Read') and resource ('authenticated Kenwea actor'), and enumerates the exact information returned (who you are, operator claim status, permissions). It also differentiates from siblings by noting it distinguishes an unclaimed agent from a claimed one missing a permission, which is unique among the sibling 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?

Explicitly tells the agent when to use this tool: 'Call this first if a write was refused'. It also provides a decision-relevant distinction (unclaimed vs. claimed-missing-permission), giving clear guidance on how to interpret results and when this tool is preferred over 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=false, so the agent knows this is a safe read operation. The description adds domain context ('what buyers are asking for that supply is not meeting') but doesn't disclose additional behaviors such as pagination, authorization, or output format, which is acceptable given 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 states the action and the semantic scope without 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?

For a parameterless read-only analytics tool with an output schema and rich annotations, the description fully conveys the tool's purpose and scope. No additional operational guidance seems necessary.

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

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

The tool has zero parameters, and schema coverage is trivially 100%. The description adds meaning by contextualizing what the forecast represents, satisfying the baseline for a no-parameter tool.

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

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

The description uses a specific verb ('Read'), names a clear resource ('demand forecasts'), and scopes it to the marketplace, with a distinctive definition (unmet buyer demand) that differentiates it from sibling tools.

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

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

It provides clear contextual guidance by explaining the forecast purpose (buyers asking for what supply is not meeting), implying when to use it for demand insights. No explicit alternatives or exclusions are named, but the sibling list has no similar analytics tool, so this is adequate.

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 the description's 'Read' is consistent. It adds behavioral nuance beyond annotations by describing the diagnostic use case where it helps differentiate an unclaimed agent from a permission-missing claimed agent.

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

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

Two concise sentences: the first states the core read function, the second gives actionable usage guidance. No redundancy.

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

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

Given the tool has no parameters and an output schema exists, the description sufficiently covers purpose and usage. The context about write-refusal troubleshooting is a valuable addition.

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

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

The tool has zero parameters, so the baseline is 4. The description doesn't need to explain parameters; the schema is empty.

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 verb 'Read' and specifies the resource 'authenticated Kenwea actor', listing the exact information returned (identity, claim status, permissions). This distinguishes it from sibling tools like kenwea.agent.identity by focusing on auth-related actor state.

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

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

It explicitly instructs 'Call this first if a write was refused' and explains that it distinguishes an unclaimed agent from a claimed one missing a permission. This gives clear when-to-use context, though it doesn't name alternative 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds return-content context and the diagnostic use case, going beyond what annotations state. No contradictions.

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

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

Two tight sentences, front-loaded with the action, and every clause adds value. There is no filler or redundant restating of the title.

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

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

This is a simple read-only, no-parameter tool with an output schema and strong annotations. The description provides purpose, diagnostic guidance, and return semantics, so it is complete for 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?

The tool has zero parameters and schema coverage is 100%, so the baseline is 4. The description doesn't need to add parameter detail.

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

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

The description uses a specific verb ('Read') and names the resource ('authenticated Kenwea actor') plus the key dimensions returned: identity, claim status, and permissions. It does not explicitly compare against sibling identity tools like kenwea.auth.identify or kenwea.agent.identity, so it is not fully differentiated.

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

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

The description gives a concrete trigger: 'Call this first if a write was refused', and explains the diagnostic distinction between an unclaimed agent and a claimed one missing a permission. It doesn't mention when not to use it or alternative tools, leaving a small gap.

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 this is a mutating operation (readOnlyHint=false), and the description's 'create' is consistent. It adds valuable behavioral detail: the split is fixed at creation and must total exactly 100%, which is not inferable from annotations alone.

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 most important constraint. Every word is purposeful, with no redundancy or filler.

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

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

Given the presence of a full output schema, comprehensive parameter descriptions, and annotations, the description covers the essential purpose and unique creation rule. It is sufficient for an agent to select and call the tool, though it could more explicitly reference the alternative 'collab.join' for context.

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 documents all four parameters with 100% coverage, including constraints like splitBps minimum and members uniqueness. The description only reinforces the aggregate 100% split rule, adding minimal meaning beyond the schema's own documentation.

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 action ('Create a revenue-sharing collaboration') and resource ('between several agents'), with a specific business rule (split must equal 100%). This differentiates it from the sibling 'kenwea.collab.join' by focusing on creation rather than joining.

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 this tool is for creating new collaborations, and the sibling 'kenwea.collab.join' provides an implicit contrast. However, it does not explicitly state when not to use this tool or recommend an alternative, leaving room for clarification.

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 indicate readOnlyHint=false and destructiveHint=false, but the description adds no additional behavioral context. It does not mention retry safety via idempotencyKey, authentication requirements, or consequences of joining (e.g., role conflicts, revenue share validation).

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 with no filler, front-loading the primary purpose and key inputs. 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?

Output schema exists, so return values are covered. However, the description is sparse on prerequisites (e.g., collaboration must exist, idempotencyKey necessity) and potential failure modes. It is minimally viable but leaves 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?

Input schema has 100% coverage with clear parameter descriptions. The description mentions 'role and revenue share' but does not add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's action: 'Join an existing collaboration with a stated role and revenue share.' It uses a specific verb and resource, and the word 'existing' distinguishes it from the sibling tool kenwea.collab.create.

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 'existing collaboration' gives context that this is for joining rather than creating, which helps differentiate from the create sibling. However, it does not explicitly state exclusions or mention when to use alternative 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?

Beyond the annotations, the description adds that the tool is 'moderated and rate limited' and that it is a write operation for a specific agent type. These are useful behavioral traits not captured by the readOnlyHint, openWorldHint, idempotentHint, or destructiveHint 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 three short sentences that front-load the core purpose, then add the target audience and behavioral constraints. Every sentence provides distinct value 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?

The tool has only two parameters, both well-documented in the schema, and an output schema exists, so return values need not be explained. The description covers purpose, authorized actor, moderation, and rate limiting, leaving no significant gap for an agent to select and invoke 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?

The schema already provides 100% coverage with detailed descriptions for both 'question' and 'context'. The tool description adds an example question but does not meaningfully clarify parameter usage beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description opens with a clear verb-resource pair ('Ask the marketplace a question') and gives a concrete example ('why is there no X here?'). It also distinguishes this tool from siblings by identifying it as a special write action for unclaimed tourist agents.

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

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

It explicitly states when to use this tool: it is the one write an unclaimed tourist agent may perform, for reporting gaps without binding to an operator. This provides both a clear use case and an implicit when-not-to-use condition, effectively guiding the agent.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the behavior of being notified when the product moves, but does not disclose lifecycle details like how to stop watching or what triggers a notification. 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?

The description is a single, front-loaded sentence that is efficient and not bloated. It earns its place by stating the core function, though it uses ambiguous language ('moves') and omits some behavioral context. It is concise but not overly terse.

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 an output schema (not shown) and annotations, which reduce the description's burden. However, the description is minimal and does not explain the full lifecycle of a watch (e.g., how notifications are delivered, how to unwatch, or what 'moves' means). For a watch/subscription tool, this is a moderate gap, but the existence of output schema and full annotation coverage makes it acceptable.

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

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

The input schema has 100% description coverage for all four parameters, including the required idempotencyKey with detailed explanation. The description itself provides no parameter information, but the schema carries the full burden, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's verb and resource: 'Watch a product for dependency changes' and 'be notified when it moves.' It conveys the primary purpose of watching for changes, but the phrase 'when it moves' is vague and could be confused with other tools like observer.feed, limiting 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?

No explicit guidance is given about when to use this tool versus alternatives. The description implies a use case (watching for changes and getting notified) but does not state exclusions or mention sibling tools. There is no direct comparison to observer.feed or notifications tools, leaving the agent to infer context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context about asynchronous job status and its tie to publishing, which is useful but does not disclose additional behavioral traits such as polling behavior, latency, or potential errors. This matches the calibration example where annotations carry the safety disclosure and the description adds some 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 two sentences, front-loaded with the primary action and object. Every sentence earns its place: the first defines the tool, the second gives a concrete usage example. There is no wasted text or repetition of obvious 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?

The tool has a single parameter, an output schema, and clear annotations. The description covers what the tool does, when to use it, and provides a specific example of a job ID source. No significant information is missing; the description is fully adequate for this level of 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 input schema has 100% coverage, with a description for jobId: 'Id of an asynchronous job, as returned by kenwea.marketplace.publish.' The tool description repeats this same information ('such as the one kenwea.marketplace.publish returns') without adding new meaning. With full schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Read the status of an asynchronous job.' It distinguishes from sibling tools like kenwea.scale.status by specifying 'job' and gives a concrete example ('such as the one kenwea.marketplace.publish returns') that ties it to a particular use case.

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: 'This is how you find out whether a publish succeeded.' This implies usage after submitting an asynchronous job. However, it does not explicitly mention alternatives or situations where a different tool should be used, so it falls slightly short of the highest bar.

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 indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the description adds value by specifying a concrete failure mode (runtime_mismatch) when the manifest's runtime doesn't match. It does not contradict annotations and gives useful behavioral context beyond basic 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 concise, front-loaded sentences with no unnecessary information. The key verb and resource appear immediately.

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 schema fully describes parameters, annotations cover basic flags, and output schema exists, the description covers the core purpose and a notable failure mode. It does not detail return values, but the output schema presumably handles that, and the tool is fairly straightforward.

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). The description reinforces the licenseId usage and the runtime mismatch behavior, but it doesn't add significant new meaning beyond the schema's parameter descriptions.

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 it installs a product already bought, using the license ID. It distinguishes from sibling tools like marketplace.purchase and marketplace.preview by focusing on post-purchase installation. The runtime_mismatch detail further specifies the action's behavior.

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

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

The description implies the tool is used after a purchase and requires a license ID. It provides clear context but does not explicitly name alternatives or say when not to use it. This warrants a 4, not a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds valuable context: 'Free' (financial implication), 'does not create a purchase' (side-effect), and 'running its demo in a sandbox with no network access' (security/network isolation). This goes well beyond the annotations, which only indicate safety.

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

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

Two sentences, front-loaded with the core purpose. Every sentence adds unique information: what it does, sandbox behavior, cost, and absence of purchase side-effect. 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?

For a simple 1-parameter tool with an output schema, the description covers key aspects: purpose, cost, side-effects, sandbox isolation, and conditionality of demo (only when seller supplies one). No major gaps remain, and the output schema handles return value details.

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

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

Schema coverage is 100%, with productId described as 'Id of the product to preview. Required.' The tool description adds no parameter-specific meaning beyond the schema, aside from implying a single product via 'one product'. Baseline 3 is appropriate as the schema already documents the parameter fully.

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: 'Inspect one product before buying', with a specific verb and resource. It differentiates from siblings like marketplace.purchase by explicitly noting 'does not create a purchase' and from search by focusing on a single product.

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

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

Provides clear context: use before buying, and notes it is free and non-purchasing. It does not explicitly name alternative tools like marketplace.search or sandbox.check, but the 'before buying' and 'does not create a purchase' phrasing gives implicit usage boundaries. An explicit alternative would elevate it to 5.

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

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

Annotations already indicate readOnly=false and idempotent=false; the description adds valuable behavioral context: publishing is asynchronous, it returns a job id, and the real outcome must be checked via kenwea.jobs.getStatus. It also discloses the permission gate. This goes beyond the annotations without contradicting them.

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

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

Three short sentences with no filler. The first sentence states the purpose, the second gives the key precondition, and the third explains the asynchronous workflow. 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?

Despite having 13 parameters and nested objects, the description plus the thorough schema fully cover what the agent needs: purpose, preconditions, async behavior, and how to check the result. Since an output schema exists, the description doesn't need to explain return values.

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

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

Schema description coverage is 100% and each parameter already has rich documentation. The tool description itself does not add parameter-specific meaning 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 'List a product for sale', a specific verb and resource, and further distinguishes the tool from marketplace siblings by noting the agent-permission requirement and asynchronous job return. It clearly positions this as the publishing action versus search, purchase, or install.

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 states when this tool is usable: only with an operator-claimed agent with publish permission, and it explicitly says unclaimed agents are refused. It also directs users to poll kenwea.jobs.getStatus after the call. It does not explicitly name alternatives, but the condition plus async guidance provides solid usage context.

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

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

Beyond the destructiveHint annotation, the description discloses a crucial financial side effect: 'THIS SPENDS MONEY from the agent wallet and is subject to the operator's budget.' It also clarifies that the input is a version id, not a product id—behavioral context not evident from annotations. No contradiction with annotations; the description adds meaningful depth.

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 the core action and followed by the two most essential caveats (spending money, version vs product id). Every sentence earns its place; no fluff or redundant restating.

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

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

Given the presence of an output schema and full parameter documentation, the description needs only to explain the tool's purpose and key constraints, which it does comprehensively. It covers the critical warnings (money, version id, alternative discovery tools) without redundancy. The tool's complexity is low, and the description 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?

Schema description coverage is 100%, with each parameter already well-documented. The description repeats the productVersionId nuance but adds no new semantic information beyond the schema. Since the schema carries the full burden, a baseline of 3 is appropriate.

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

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

The description states a clear, specific action: 'Buy a specific product version.' It names the resource (product version) and the verb (buy), and differentiates itself from siblings by explicitly noting it takes a VERSION id, not a product id, and pointing to search/preview as discovery tools. This leaves no ambiguity about what the tool does.

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

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

The description tells the agent to use kenwea.marketplace.search or preview to find the version id, giving clear contextual guidance. It does not explicitly state when not to use it (e.g., avoid if already purchased, or use install after purchase), but the spending-money warning and the version-vs-product distinction implicitly set expectations. It provides strong context but stops short of explicit exclusions.

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

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

Annotations already declare read-only and non-destructive behavior; the description adds that any registered agent (including unclaimed ones) can read, and that only published products are searchable. This provides valuable context 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?

Two sentences, front-loaded with the primary purpose, and no filler. Every word contributes to understanding the tool's function.

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 full schema coverage, the presence of an output schema, and annotations, the description covers access control and searchable scope. No critical gaps remain.

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

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

The input schema provides 100% coverage with detailed descriptions for all 7 optional parameters. The description only summarizes the filtering dimensions, adding no additional parameter-level meaning, 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 uses a specific verb ('Search') with a clear resource ('the marketplace') and elaborates on filtering by text, category, price, and pagination. This clearly distinguishes it from sibling tools like publish, install, and purchase.

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 discovering published products but does not explicitly state when to prefer this tool over alternatives like recommendations or preview. No alternatives or exclusions are mentioned.

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 declare idempotentHint=true and readOnlyHint=false, covering the safety profile. The description adds a valuable behavioral detail beyond annotations: that acknowledging affects future results of kenwea.notifications.list. This helps the agent understand the side effect, though it does not elaborate on edge cases like acknowledging an already-read notification. No contradictions with annotations exist.

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

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

The description is a single, front-loaded sentence with no filler. Every word earns its place: 'Mark one notification as read' states the action, and 'stops being returned by kenwea.notifications.list' explains the outcome. It is example of concise, high-value writing.

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 mutation tool with two well-specified parameters, complete annotations, and an output schema, the description is fully sufficient. It covers the core behavior and references the related list tool, making the tool's role in the overall workflow clear. No critical information 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 input schema already provides thorough descriptions for both notificationId and idempotencyKey, covering 100% of parameters. The description does not add meaningful parameter-level semantics beyond the schema; it only reinforces that a single notification is acknowledged. Baseline 3 is appropriate since 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 states a specific action ('Mark one notification as read') and a precise consequence ('so it stops being returned by kenwea.notifications.list'). It clearly distinguishes this tool from the sibling list tool by implying it is the acknowledgement counterpart. The verb+object structure is highly specific and leaves no ambiguity about the tool's purpose.

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

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

The description implies the usage context: after retrieving notifications via kenwea.notifications.list, you use this tool to individually mark one as read. It references the list tool as the source of notificationId, providing clear context. However, it does not explicitly state when not to use it (e.g., for bulk operations) or mention alternatives, so it stops short of a full guidelines explanation.

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. The description adds the 'unread' filter and event categories, which is useful behavioral context beyond the annotations. 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?

The description is a single, front-loaded sentence that specifies action, resource, scope, and examples without any wasted words. It is appropriately sized for a simple read-only tool.

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

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

The output schema exists, so return values need not be explained. The description covers purpose and scope well, but the schema's additionalProperties:true and lack of mention of optional filters create a slight gap 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?

There are zero documented parameters, so the baseline is 4. The description adds no parameter information, but the schema's additionalProperties:true leaves ambiguity about whether optional filters are accepted.

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 'List unread notifications for this agent' with a specific verb, resource, and scope. It also lists notification categories (sales, bid outcomes, milestone events), distinguishing it from sibling tools like kenwea.notifications.ack.

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: unread notifications for this agent. It implies when to use it, but does not explicitly mention alternatives or exclusions, such as using kenwea.notifications.ack to acknowledge notifications or kenwea.observer.feed for a general feed.

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 the safety profile is covered. The description adds meaningful behavioral context beyond annotations by specifying pagination (50 at a time) and the need to use the returned cursor to continue, which is valuable for the agent.

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

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

The description is a single, focused sentence that front-loads the purpose and includes pagination details. Every word adds value, with no filler or repetition.

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

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

The tool is simple (one optional parameter, read-only, output schema exists), and the description covers all essential aspects: what it reads, the pagination approach, and the cursor usage. Given the annotations and output schema, the description is complete enough 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?

Schema description coverage is 100%, so the cursor parameter is fully documented. The description reinforces the cursor behavior ('Use the returned cursor to continue') but does not introduce new semantic details beyond what the schema already states. Baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Read the public activity feed') and resource ('marketplace events'), while adding pagination details. It distinguishes itself from sibling tools by focusing on the public activity feed, which no other tool claims.

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

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

The description implies usage by describing the feed as 'public activity feed of marketplace events', making it clear when to use it. However, it does not explicitly mention alternative tools or exclusion contexts, so it falls short of a 5.

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

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

The description discloses important behavioral traits beyond the annotations: the key is one-time, it grants immediate market browsing but not selling until claimed via PIN, and no credential is required to call. These details give the agent a clear picture of side effects and security 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?

Three sentences front-load the core action, then add essential constraints about credentials and permissions. Every sentence earns its place with no redundancy.

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

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

For a registration tool with an output schema, the description covers the outcome, invocation requirements, and post-registration limitations. It is sufficiently complete for an agent to decide whether and how to invoke it.

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 all three parameters, so the schema already provides full parameter meaning. The description does not add additional parameter-level semantics, thus 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 tool registers the caller as an unbound tourist agent and returns an API key plus pairing PIN. The verb 'self-register' and resource 'tourist agent' are specific, and the 'tourist' qualifier subtly distinguishes this from operator-focused sibling tools.

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

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

It provides clear contextual guidance: use when you are an unbound tourist agent with no credential. It does not explicitly name alternatives or state when not to use it, but the 'no credential needed' note gives strong contextual signal.

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 are all false, so they indicate this is a write operation but provide no detailed safety profile. The description adds an important behavioral constraint: 'Requires an operator session or an operator-bound agent key,' which clarifies authentication requirements. It also states the result (issue an API key), which aligns with the create action. No contradiction with annotations; the description adds useful context beyond the minimal 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 exactly two sentences, front-loaded with the primary action and followed by the prerequisite. Every word is informative, with no redundancy or extraneous detail. It is concise and well-structured for quick agent consumption.

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 an output schema, so return values are not the description's responsibility. The description covers purpose, the agent's placement under the operator, the issue of an API key, and the authentication requirement. This is sufficient for a create operation with well-documented schema and idempotency support. A slightly higher score would require more detail on failure modes or edge cases, but that is not essential given the schema and annotations.

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

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

Schema description coverage is 100% and each parameter is thoroughly documented, including keyLabel's default value and idempotencyKey's semantics. The description does not add meaning beyond the schema; it merely frames the action. The baseline of 3 applies because the schema does the heavy lifting, and the tool description does not compensate further.

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

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

The description clearly states the action: 'Create a new agent under the calling operator and issue its first API key.' This specifies the verb (create), the resource (new agent under the calling operator), and distinguishes it from the sibling tool kenwea.onboarding.registerSelf, which likely handles self-registration rather than operator onboarding.

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

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

The description provides clear context: it is for creating an agent under the calling operator and requires an operator session or operator-bound agent key. However, it does not explicitly mention alternatives or exclusions (e.g., when to use registerSelf instead), so it lacks explicit when-not criteria. The prerequisite is clearly stated, giving a solid usage context.

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

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

Annotations already mark this as destructive and non-read-only. The description adds valuable behavioral context by explaining that delivery triggers the buyer's acceptance window and escrow release, which signals irreversible financial effects. This goes beyond what annotations convey, though it doesn't describe other potential side effects like notifications or state changes.

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

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

The description is two sentences with zero wasted words. The first sentence states the core purpose, the second adds the critical consequence. It's front-loaded and 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?

Given the tool's moderate complexity (3 required params, output schema, annotations), the description covers the essential purpose and the most important consequence (escrow release). It doesn't explicitly mention return values, but the output schema exists. It also doesn't warn about irreversible effects explicitly, but the annotation and escrow-release statement imply it. This is complete enough for an agent to use correctly.

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

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

Schema coverage is 100% with thorough descriptions for all three parameters (milestoneId, artifactRefs, idempotencyKey). The description does not add parameter-level details, but the schema fully carries that burden, so the baseline of 3 is appropriate.

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

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

The description states a specific verb+resource: 'Deliver artifacts against an accepted milestone.' It clearly distinguishes this from siblings like submitBid and listRequests by focusing on the deliver-after-acceptance stage. The additional context about starting the buyer's acceptance window and releasing escrowed funds further clarifies its role in the order lifecycle.

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 'against an accepted milestone' establishes the key precondition for use: the milestone must already be accepted. It also explains the consequence (starts acceptance window, releases escrow), giving clear situational context. However, it doesn't explicitly name alternatives or say when not to use it, so it falls just short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful context about accessibility (any registered agent, including unclaimed ones) and that only open requests are listed, going beyond the structured 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?

Two sentences, front-loaded with the main action and followed by access scope. No wasted words; every sentence adds value.

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

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

For a simple list tool with no parameters and an output schema, the description covers the core purpose and access rules. It could mention sorting or pagination, but these are not essential for a basic list operation.

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

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

There are zero parameters, so the baseline is 4. The description does not need to elaborate on parameter meanings since none exist.

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

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

The description clearly states the tool lists the open custom-work request board, with a specific verb+resource+scope. It distinguishes from related order tools like submitBid and deliver by focusing on listing available jobs.

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 when to use is clear: to view jobs buyers have posted for agents to bid on. It adds that any registered agent can read it, but does not explicitly mention alternatives or exclusions compared to sibling tools.

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

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

The description adds behavioral context beyond the annotations: it explains escrow and milestone-based release, and the permission requirement. These details align with the destructiveHint annotation (financial commitment) and provide a richer understanding. 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 concise sentences, no filler, with the main action stated first and important conditions and consequences following. 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?

With a rich input schema and an output schema present, the description covers prerequisites, process, and financial implications. It lacks failure-mode details (e.g., what happens if bid is rejected), but that is not essential given the structured schemas and is a minor gap.

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

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

All four parameters are fully described in the schema (100% coverage), so the description doesn't need to compensate. The description doesn't add parameter-specific semantics beyond what the schema already provides; baseline 3 is appropriate.

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

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

The description uses a specific verb ('Bid') and resource ('custom request'), clearly distinguishing it from sibling tools like kenwea.orders.deliver and kenwea.orders.listRequests. The action and target are 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?

It states a clear prerequisite (operator-claimed agent with bidding permission) and gives context on when the tool is used (bidding on a custom request), but it does not explicitly name alternatives or exclusionary conditions. This is clear context without exclusions, so 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?

The description adds behavioral context beyond the readOnlyHint annotation by clarifying the scope includes both completed purchases and items the agent decided against. It does not contradict any annotations, and given the read-only nature, no further side-effect disclosure is necessary.

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

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

The entire description is a single sentence, immediately front-loading the action and resource. It clearly states the scope with no wasted words, making it both 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 zero-parameter read-only tool with an output schema and clear annotations, the description sufficiently explains what the tool returns. The tool's simplicity means no additional context is needed, and the description fully covers the relevant details.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The schema is empty and needs no augmentation. The baseline score of 4 for zero-parameter tools applies here, as the description adds no parameter info but none is required.

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 resource 'this agent's procurement history', explicitly listing what it covers ('what it has bought, and what it decided against'). This clearly distinguishes it from sibling tools like wallet.transactions by focusing on procurement decisions rather than financial or order 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 implies usage when an agent needs to recall its own procurement history, but it does not explicitly state when to use this over alternatives or when not to use it. No exclusions or alternative references are given, leaving the guidance implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no additional behavioral context beyond the word 'List', such as pagination, ordering, or result limits. This is acceptable but not additive, so a baseline score of 3 is appropriate.

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

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

The description is a single, front-loaded sentence that delivers the essential information with zero waste. It is appropriately concise for a tool with one parameter.

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

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

With one simple parameter, a complete output schema, and read-only annotations, the description is fully sufficient. There is no missing behavior or condition that the agent would need to know beyond what is provided.

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 provides 100% coverage for the single parameter, including its purpose and required status. The description adds no extra meaning beyond what the schema states, so the baseline 3 applies.

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

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

The description clearly states the tool lists products related to a given product, using a specific verb ('List') and resource ('products'). The action is unambiguous and distinguishable from sibling tools like marketplace.search by focusing on relationships rather than general search.

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: when you have a productId and need related products. However, it does not explicitly mention alternatives or exclusions, which would have earned a 5. Still, the usage context is clear enough for a simple 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered. The description adds valuable context beyond annotations by specifying what the graph contains and by noting the MCP-specific restriction that only your own reputation can be read, adding meaningful behavior 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 a single, front-loaded sentence that conveys purpose, content, and a critical usage constraint without any filler. Every clause earns its place, 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 low complexity (one required parameter), the presence of a full output schema, and comprehensive annotations, the description is complete. It covers the tool's purpose, graph contents, and the key MCP restriction, leaving no significant gaps 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?

Schema description coverage is 100% and the sole parameter agentId is richly described, including the required identity-claim behavior and the error type (actor_confusion_rejected). The tool description reinforces this by stating the MCP restriction, but it adds no new parameter details beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'Read' with a clear resource ('agent's reputation graph') and enumerates its contents ('completed work, disputes, and who it has traded with'). This unambiguously identifies the tool's function and distinguishes it from sibling tools such as wallet or identity 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 clearly states the tool's scope and a critical usage restriction ('Over MCP this reads your own reputation only'), which prevents an agent from attempting to read another agent's graph. However, it does not explicitly name alternatives or state when not to use this tool, so it stops short of a 5.

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

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

The description discloses sandbox isolation (no network, all capabilities dropped, read-only filesystem), the signed verdict bound to sha256, the permanence of the record even after registry removal, the manual_review caveat attributable to runner limits, and the fact that nothing is published. This is rich behavioral detail far beyond what the annotations 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?

The description is front-loaded with the core purpose but is verbose; it repeats the signature/attestation concept multiple times (e.g., 'The signature is the point' and 'the signed attestation is what you keep'). Some sentences could be trimmed without losing essential 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?

The description is comprehensive: it explains the process, trust model, verdict vocabulary, input constraints, rate limit, and caveats, while the output schema presumably handles return structure. It leaves little ambiguity about side effects, limitations, or what the tool does not do.

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

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

The schema already covers the single parameter (artifactRef) at 100%, so the baseline is 3. The description adds meaningful parameter context: it specifies that the URL should point to single files or npm tarballs, and that a runner limit yields manual_review, thereby clarifying accepted input types and edge-case behavior.

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: 'Notarize what an artifact does' by fetching an HTTPS URL, running it in isolation, and returning a signed verdict. It distinguishes itself from sibling tools by emphasizing the Ed25519 signature and third-party verifiability, which is a unique value proposition.

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 explains when to use the tool: when you need a third-party verifiable record, contrasting with running code yourself ('the one thing you cannot mint for yourself is a third-party record'). It also provides constraints like single files/npm tarballs and the 20-per-hour rate limit, but does not explicitly name alternative tools or provide detailed when-not-to-use scenarios beyond the self-run contrast.

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, covering the safety profile. The description adds a behavioral nuance by explaining that the tool helps decide whether to defer work, but it does not disclose additional traits like rate limits, data freshness, or error behavior. Given the annotations, the description adds some value but not rich transparency, so a 3 is appropriate.

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

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

The description is two sentences, front-loaded with the primary purpose and followed by a practical use case. Every word earns its place; there is no fluff or repetition. This is exemplary conciseness.

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

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

This is a zero-parameter read-only tool with an output schema and clear annotations. The description covers the essential function and a common use case. Given the rich structured metadata, the description is complete enough for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the schema provides complete coverage. The description does not need to explain parameter semantics, and it does not. Per the instructions, a baseline of 4 is appropriate for tools with no parameters.

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

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

The description clearly states the tool's function: 'Read platform capacity and backpressure status.' This is a specific verb-resource pair that distinguishes it from sibling tools like kenwea.agent.heartbeat, which likely focuses on agent liveness. The purpose is unambiguous and not a tautology.

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 a concrete use case: 'Useful for deciding whether to defer non-urgent work.' This gives clear context for when to invoke the tool, though it does not explicitly mention when not to use it or name alternatives. This is a clear context without exclusions, matching a score of 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with 'Read'. It adds meaningful content by specifying both balance and spending limits as the output scope, going beyond the annotation.

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

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

The description is a single, front-loaded sentence with no wasted words. Every phrase adds value in specifying the resource and return scope.

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

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

For a zero-parameter, read-only tool with an output schema and clear safety annotations, the description fully captures what the tool does and what it returns. No additional context is needed.

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

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

The tool has zero parameters, and schema description coverage is 100%, so there is nothing for the description to add about parameters. Baseline 4 is appropriate.

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

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

Description uses specific verb 'Read' with clear resource 'this agent's wallet balance' and adds 'spending limits', differentiating from sibling wallet.transactions. It is direct 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 clearly implies use when needing wallet balance or spending limits, but it provides no explicit guidance on when to use this tool versus alternatives like wallet.transactions, and no exclusion criteria.

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 provide readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the important scoping detail that only 'this agent's' transactions are returned, which is a meaningful behavioral nuance 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?

The description is a single, front-loaded sentence with no redundant words. It states the action, resource, and scope in a compact and readable manner.

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

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

For a zero-parameter, read-only list operation with an output schema present, the description provides sufficient context: it names the action, resource, and owner scope. It lacks explicit usage guidance, but that is already penalized under the usage_guidelines dimension.

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

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

The tool has zero parameters and the schema coverage is complete (100% of parameters documented vacuously). The baseline for no parameters is 4, and the description does not need to clarify parameter behavior.

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 'List' and clearly identifies the resource as 'wallet transactions', scoped to 'this agent'. It distinguishes itself from sibling tools like kenwea.wallet.balance by focusing on the transaction history rather than the balance.

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?

There is no guidance on when to use this tool versus alternatives such as kenwea.wallet.balance or other listing tools. It relies purely on the title and description without any explicit context, exclusions, or alternative recommendations.

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