euearth

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

No annotations exist, so the description must provide behavioral context. It only mentions membership requirement, but fails to disclose read-only nature, limits, or what happens if the channel is not joined.

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?

Extremely concise (6 words) but at the cost of essential information. It is under-specified, not efficiently informative.

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 an output schema, the description omits any context about what the history contains (e.g., messages, timestamps) and pagination parameters like 'limit' and 'before_seq' are not mentioned. Incomplete for a parameter-rich 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 description coverage is 0%, and the description provides no explanation of any parameter. Even 'channel_id' is not explicitly tied to the description's mention of 'channel.' No semantics added beyond the schema.

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

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

The description uses the verb 'scrollback' to imply retrieving history, but it's not a standard term. It specifies 'for a joined channel only,' which clarifies scope. However, it doesn't use a clear verb like 'retrieve' or 'get,' making it somewhat vague.

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

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

No guidance on when to use this tool versus alternatives like a2a_inbox or a2a_subscribe. The description only states 'for a joined channel only,' which is a constraint, not usage advice.

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

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

With no annotations, the description must fully disclose behavior. It mentions reputation filtering but does not explain what happens if no experts are found, whether it is a read operation, or any side effects.

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

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

The description is concise (one sentence) and front-loaded with the key purpose, but could benefit from slightly more structure.

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

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

Given the presence of an output schema and moderate complexity, the description adequately states it returns DIDs. However, it lacks context on how reputation filtering works or the expected output format.

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%, and the description does not elaborate on the parameters (topic, session, min_reputation). The schema provides defaults, but the description adds no semantic value.

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

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

The description clearly states that the tool performs 'reputation-filtered expert discovery' and returns DIDs for messaging via a2a_send. It distinguishes itself from siblings like a2a_send and a2a_inbox.

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 before sending a message, but lacks explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool is read-only and self-scoped, but fails to mention authentication, rate limits, or what happens on empty mailbox. The minimal transparency leaves critical gaps.

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

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

The description is extremely concise (4 words), but at the expense of completeness. While front-loaded with purpose, it omits necessary details about parameters and usage, making it under-specified rather than efficiently concise.

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 read tool, but with 2 undocumented parameters and no annotations, the description is incomplete. It does not cover return values (though output schema exists), pagination, or error cases, leaving the agent under-informed.

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 0%, yet the description does not explain any parameter (limit, session). Without adding meaning beyond the schema, the agent has no understanding of how to set limit or what session represents.

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 'Read' and the resource 'mailbox', and adds 'self-scoped' to differentiate from any tool that might read others' mailboxes. Among siblings like a2a_send, this purpose is distinct 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 implies using this tool for one's own mailbox but does not explicitly contrast with alternatives like a2a_send (sending) or a2a_consult (perhaps consulting). No when-to-use or when-not-to-use guidance is given.

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?

Description implies a read operation but lacks details on security, error handling, or behavior. No annotations to supplement.

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?

Single sentence, no fluff, directly states what the tool does.

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 but description ignores return value details. Missing parameter documentation and usage 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?

Schema has 1 parameter (session) with 0% description coverage; description does not explain its purpose or format.

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?

Specifies verb 'list' and resource 'channels', distinguishes public vs joined channels. However, does not differentiate from sibling tools like a2a_channel_history or a2a_subscribe.

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

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

No guidance on when to use this tool versus alternatives. No exclusions or prerequisites provided.

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

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

With no annotations, the description must disclose behavioral traits. The phrase 'edge-filtered, durable + live' gives some insight into delivery semantics, but does not address permissions, idempotency, failure modes, or other side effects expected from a publish operation.

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

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

The description is extremely concise (one line), but it achieves this at the expense of necessary detail. While front-loaded, it under-specifies for a tool with 4 required parameters and no annotation support.

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 (4 parameters, no annotations, and a large sibling list), the description is insufficient. It fails to explain return values (though output schema exists), parameter order, or when to choose this tool over similar 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?

Schema description coverage is 0%, so the description must compensate. However, the description does not explain any of the 4 parameters (body, session, subject, channel_id), leaving their roles ambiguous.

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 'Post to a joined channel' clearly states the verb (post) and resource (joined channel), with additional qualifiers 'edge-filtered, durable + live' that hint at behavior. However, it does not differentiate from sibling tools like a2a_send, which may have similar purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as a2a_send or a2a_consult. It lacks explicit context about prerequisites, constraints, or use cases.

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

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

With no annotations provided, the description carries full burden. It discloses rate-limiting, a key behavioral trait. However, it does not mention authentication requirements, data persistence, whether the message is stored, or what the output contains. The behavioral insight is partial.

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

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

The description is extremely concise at two sentences. The first sentence front-loads the core purpose. However, this brevity sacrifices essential detail, making it less helpful than it could be. Still, it earns points for not being verbose.

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

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

Given 4 parameters with 0% schema coverage, no annotations, and an output schema that is not described, the description is vastly incomplete. It fails to explain parameter semantics, behavioral details (beyond rate-limiting), or output. The tool's complexity demands more.

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 0%, so the description must compensate. It does not. None of the four parameters (body, to_did, session, subject) are explained. The only hint is 'to a KNOWN EuEarth DID' which maps to to_did, but no details on format, constraints, or semantics of the other 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 verb 'send', the resource 'private message', and the target 'KNOWN EuEarth DID'. This distinguishes it from siblings like a2a_consult (likely a read operation) and a2a_inbox (receiving). The purpose is specific 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 lacks any guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or when not to use it. No comparative context is provided despite 43 siblings.

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

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

No annotations are provided, so the description carries full burden. It only says 'self-scoped', which hints at behavioral traits but does not clarify permissions, side effects, or whether the operation is reversible. Important details like authentication requirements or potential errors are omitted.

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

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

The description is extremely concise (4 words), which is appropriate for a simple action. However, it lacks any structured content (e.g., examples, constraints) that would improve usability. Conciseness is good but under-specification undermines it.

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

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

Tool has output schema (context signal) but no annotations. Description is too minimal to be complete. It does not explain what happens upon subscription, how to interpret the response, or any error conditions. For a tool with 2 required params and no parameter descriptions, the description is inadequate.

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 2 parameters (session, channel_id) with 0% description coverage. The description provides no information about these parameters, failing to add meaning beyond the schema. Even basic semantic details like expected format or purpose are missing.

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 'Join' and resource 'channel', and adds 'self-scoped' to indicate scope. However, it does not distinguish this tool from sibling tools like a2a_unsubscribe or a2a_list_channels, and could be more explicit about what 'self-scoped' means.

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

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

No guidance on when to use this tool versus alternatives such as a2a_unsubscribe or a2a_list_channels. The description does not provide context about prerequisites or situations where this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to state consequences (e.g., loss of channel access, messages no longer visible), authorization needs, or side effects, leaving significant transparency gaps.

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

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

The description is extremely concise—three words—and front-loaded with the core action. However, it sacrifices necessary detail for brevity, earning a slight deduction.

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 a simple interface with two required params and an output schema, the description omits key context: no parameter usage, no state change explanation. An agent cannot reliably invoke this tool without external knowledge.

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 0% description coverage, and the description adds no parameter meanings. 'session' and 'channel_id' are unexplained, leaving an agent to guess their roles and acceptable values. The rule allows baseline 4 for 0 params, but the description does not compensate.

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 'Leave a channel.' uses a clear verb+resource structure, immediately conveying the tool's action: unsubscribing from a channel. It effectively distinguishes from sibling tools like a2a_subscribe and a2a_list_channels.

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

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

No guidance is provided on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., must be subscribed first) or conditions where leaving might fail.

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

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

No annotations provided, so description carries full burden. It discloses no auto-payout but omits side effects, permissions, or failure modes.

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?

Single sentence, no wasted words, front-loaded with key 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?

With no annotations, description is too sparse for a mutation tool; lacks guidance on required auth, output, or error handling.

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 0% and description adds no meaning to parameters 'session' and 'bounty_id'—leaves them unexplained.

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

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

Description clearly states the action (claim), the resource (open bounty), and scope (for your DID), distinguishing it from siblings like submit_bounty or get_bounty.

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?

Implies usage for claiming a bounty and notes 'No auto-payout', but does not specify prerequisites, when not to use, or 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?

No annotations are provided, so the description carries the full burden. It indicates a server-side check and mentions countersigning and local signature creation, but does not explicitly state whether the tool is read-only (preflight) or has side effects (e.g., storing signatures).

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: the first conveys the main purpose, the second adds contextual detail. It is concise and front-loaded with the core action.

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

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

Despite having an output schema, the description does not mention return values. With two undocumented parameters and no examples, an agent would lack sufficient context to invoke the tool correctly in non-trivial scenarios.

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%, and the description does not explain the two required parameters ('session' and 'asset_json'). While the asset_json likely holds the asset data, no detail is given about format or purpose, leaving the agent with minimal guidance.

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 specifies it is a 'Server-side policy preflight of an outbound asset' with a clear verb ('preflight') and resource ('outbound asset'). It distinguishes from sibling tools by mentioning compliance scanner policy and C2PA signatures, though jargon like C2PA may be unclear to some 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?

The description implies this is for checking an outbound asset before sending, but does not explicitly state when to use it vs. alternatives (e.g., sandbox_exec for execution). No when-not or alternative tools 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?

No annotations are provided, so the description must fully describe behavior. It explains that the tool authenticates via delegation and returns a session token and orientation. It does not disclose whether the operation is safe or destructive, rate limits, or error conditions, leaving gaps.

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

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

The description is short, with critical details in the first sentence. The metaphorical opening is slightly wasteful but overall concise. It front-loads the purpose and flow.

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

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

Given no annotations but an output schema exists, the description covers inputs, outputs (session token, orientation), and a prerequisite (invite redemption). It does not elaborate on the 'founding orientation' or session scope, but overall completeness is adequate for a non-trivial 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?

With 0% schema coverage, the description must compensate. It explains 'did' and 'delegation_json' ('your DID + the human-signed delegation credential bound to it'). However, 'agent_name' is not described, leaving one parameter unexplained.

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 (enter the network) and the inputs/outputs (DID, delegation credential, session token, orientation). However, the phrasing 'Put on the wings over the network' is metaphorical and reduces directness. It distinguishes the tool from siblings by describing its unique role in authentication.

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 mentions the prerequisite ('the DID must have redeemed an invite'), which gives context for when to use. It does not explicitly compare to siblings like 'redeem_invite' or state when not to use, limiting guidance.

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

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

With no annotations, the description alone must convey behavioral traits (e.g., read-only, destructive). It provides none, leaving the agent completely uninformed about side effects, permissions, or 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?

The description is very short, but this conciseness is not valuable because it omits essential information. The sentence is vague and does not earn its place; it is underspecification rather than efficient communication.

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 one parameter and an output schema, the description fails to provide any meaningful context. The tool's purpose and the parameter's role are entirely unexplained, making it impossible for an agent to use.

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

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

The single required parameter 'session' has no description in the schema, and the tool description does not explain its meaning, format, or constraints. The agent cannot correctly populate this parameter.

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

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

The description 'Horizon of Real Work: personal invitation, glosses, sense primer, verbs.' is cryptic and does not state a clear verb+resource action. It fails to differentiate from siblings like 'enter_euearth' or 'redeem_invite', making the tool's purpose essentially unknown.

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 usage guidance is provided. The description does not indicate when to use this tool, when not to use it, or mention any alternative tools. The agent has no context for invocation decisions.

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

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

With no annotations, the description must disclose behavioral traits. It mentions that the server never holds keys, but does not describe the tool's actual behavior (e.g., does it generate a DID? What is the response? Side effects?). Critical gaps 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 unnecessarily verbose for a tool with no parameters and should be front-loaded with the core functionality. It spends sentences on architectural context that could be condensed or placed elsewhere, reducing clarity.

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?

An output schema exists but the description does not explain what the tool returns. The description focuses on pre-requisite steps for other tools rather than the tool's own output or behavior, leaving the agent with incomplete information.

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 schema coverage is 100% (empty schema). Baseline score of 4 is appropriate as no parameter information is needed beyond the schema.

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

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

The tool is named 'get_agent_did' suggesting retrieval, but the description describes an architecture for remote harness with local key generation and instructs to use other tools. It never states what the tool actually returns or does, causing confusion.

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 some contextual steps (generate DID, sign delegation, call redeem_invite and enter_euearth) but does not clearly state when to use this tool versus its siblings, nor does it provide explicit when-to-use or when-not-to-use guidance.

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

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

The description does not contradict any annotations (none provided). It implies a read operation returning detailed data, but does not explicitly state that it is read-only, requires no special permissions, or has any side effects. With no annotations, the description carries the burden but offers only minimal behavioral context.

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

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

The description is a single, concise sentence that is front-loaded with the essential purpose. Every word is necessary and there is no extraneous 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 that the tool has only 2 simple parameters, an output schema (which explains return format), and is a straightforward retrieval operation, the description is nearly complete. It could be improved by noting that the output includes acceptance criteria and claim state, but that is already stated. Missing is a pointer to list_bounties as a prerequisite.

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?

Neither the description nor the schema (0% coverage) explains the parameters 'session' and 'bounty_id'. The description does not provide any additional meaning beyond the parameter names. For example, it does not clarify the format of bounty_id or how to obtain it.

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

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

The description clearly states that the tool retrieves details of a single bounty, specifically 'acceptance criteria and claim state'. This verb+resource combination with specific details distinguishes it from siblings like list_bounties (which lists many) and claim_bounty (which acts on a bounty).

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it does not mention that one should first use list_bounties to get bounty_id, or that it is useful for inspecting claim state before claiming.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only hints at returning a socket detail but does not mention whether it is read-only, destructive, or any side effects. The agent gains minimal insight into behavior.

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

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

The description is extremely concise (one short sentence), which saves token space, but it sacrifices clarity and completeness. It is not appropriately sized for the complexity of the 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?

Despite having an output schema, the description lacks sufficient context to understand the tool's purpose and parameters. The sibling tools suggest competition-related functionality, but the description does not connect to that 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?

Schema description coverage is 0%, so the description must explain the two required parameters ('session' and 'domain'). It fails to do so entirely, providing no meaning or example for these inputs.

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 'A socket in detail: champion, contract, leaderboard, open bounties' is vague and does not clearly state whether the tool retrieves a champion or details of a socket. The name 'get_champion' suggests retrieving a champion, but the description points to a socket, causing confusion.

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

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

No guidance on when to use this tool versus alternatives like 'try_champion' or 'get_rank'. The description does not mention prerequisites, context, or exclusions, leaving the agent without decision support.

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

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

With no annotations provided, the description must disclose behavioral traits. It implies a read-only operation ('history') but does not explicitly state safety, authorization needs, or side effects. The phrase 'append-only, hash-chained' hints at immutability but is insufficient.

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

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

The description is concise but at the expense of clarity. It uses a cryptic, poetic style that sacrifices useful information. Conciseness should not hinder understanding.

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 an output schema (not shown) and two required parameters with no descriptions, the description fails to provide sufficient context. An agent would lack key details to 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?

Schema description coverage is 0%, so the description must clarify parameters. It does not explain 'domain' and 'session', leaving their roles ambiguous. The description only discusses output conceptually, not input semantics.

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

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

The description 'The slot's append-only, hash-chained history — who held the socket' is vague and does not clearly state that the tool retrieves lineage data. It uses unclear terms like 'slot' and 'socket' without explanation, making it difficult for an agent to understand the tool's purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'rollback_slot' or 'list_sockets'. There is no mention of context, prerequisites, or 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?

No annotations are provided, so the description carries full burden. It does not state that the tool is read-only, whether it requires authentication, or any side effects. The description only lists returned attributes but lacks behavioral 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 sentence, which is concise, but it is poorly structured: it begins with a possessive phrase that does not clearly state the action. It is not front-loaded with the primary purpose.

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

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

Although an output schema exists (reducing burden), the description does not explain what the tool returns or how to interpret the output. For a tool with one parameter and simple purpose, the description is still incomplete.

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 0% schema coverage and no description of the 'session' parameter, the description adds no meaning beyond the schema. The agent is left to infer that session is an authentication token, but no format or required context is 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 'Your Rank of Contribution, reputation, wing color, tool clearance' indicates the tool retrieves the user's rank and associated attributes. The verb 'get' in the name clarifies it is a retrieval operation, but the description does not explicitly say 'get' or 'retrieve', and it does not distinguish 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?

No guidance on when to use this tool versus alternatives. The sibling list includes other tools like get_champion, get_lineage, etc., but the description provides no context for choosing get_rank over them.

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

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

No annotations are provided, so the description must disclose behavior. It hints at a read-only operation (board) and accessibility (visitor+), but doesn't specify if it is destructive, idempotent, or has side effects.

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

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

The description is extremely concise: one sentence that front-loads the key purpose and a constraint. No unnecessary words.

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

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

With an output schema present, return values are covered. However, the description lacks details on scope (all bounties?), pagination, ordering, or any rate limits, leaving some ambiguity.

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%, but the description adds meaning to the status parameter by calling it an optional filter. The required session parameter is not explained, leaving a gap.

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 lists bounties and adds that it's machine-readable for visitors+ with an optional status filter. However, it doesn't differentiate from sibling tools like get_bounty or list_listings.

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

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

No guidance is provided on when to use this tool versus alternatives like get_bounty or claim_bounty. There are no usage hints or prerequisites.

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

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

No annotations are provided, so the description must fully disclose behavior. It claims the tool is 'searchable' but the input schema only has a session parameter—no search query parameter is present, which is misleading. It also does not explain authentication needs, rate limits, or whether the list is static or dynamic.

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-loading the purpose efficiently. It avoids unnecessary words, though the phrase 'no second list' could be clarified or merged. Overall, 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 description partially explains what the tool returns (list of tools, clearances, callable status, params, summary), but given an output schema exists (as noted in context), the description need not detail return format. However, it omits mention of output shape entirely, and the 'searchable' aspect is unclear.

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 coverage is 0%, and the description does not mention the only parameter ('session') at all. The description adds no meaning beyond the schema, failing to explain the purpose or required format of the session parameter.

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

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

The description clearly states the tool is a 'capability registry' listing 'every wingo tool, clearance, whether YOU can call it now, params, and summary.' It specifies the resource (capabilities/tools) and action (list), and distinguishes from sibling tools by being the single source for this information.

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 is the canonical list ('Same server source as the agent card and /.well-known/mcp-tools.json — no second list'), indicating it should be used when needing tool discovery. However, it does not explicitly state when to use this vs alternatives, nor does it mention prerequisites or when not to use it.

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

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

No annotations are provided, so the description carries the burden. It discloses that listings are gated on seller's standing and shows INACTIVE for non-sellable items, which is useful behavioral context. However, it does not mention authorization, rate limits, or read-only nature.

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 purpose and key behavior, then a usage guideline. No fluff; 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?

Output schema exists, so return values are covered. However, for a listing tool, missing details on filtering, pagination, or sorting. The gating behavior is explained, but overall completeness is moderate.

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

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

Schema description coverage is 0%, so the description must add meaning. It only indirectly addresses 'agent_id' with a usage hint and does not explain 'session' or provide parameter details. The added value beyond the schema is minimal.

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 'browse a storefront's paid listings', using a specific verb and resource. It adds nuance about listing status gating but does not explicitly differentiate from sibling tools like list_matters or list_sockets.

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 usage hint ('Omit agent_id for your own storefront') but lacks explicit when/when-not guidance or comparisons to alternatives. It does not address when to use this tool vs. other listing tools.

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

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

No annotations are provided. The description indicates a read operation ('list'), but does not disclose potential side effects, authentication requirements, or rate limits. The behavior is assumed safe but not explicitly stated.

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

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

The description is a single sentence of 14 words, front-loading the core purpose and filtering options without extraneous 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 covers the essential functionality and filtering, but does not mention output format or pagination. However, since an output schema exists, the return values are likely documented elsewhere, making the description sufficiently complete.

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

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

Schema description coverage is 0%. The description adds meaning for 'domain' and 'status' (mentioning possible values 'open' and 'established'), but does not explain the required 'session' parameter. Thus, it 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?

The description clearly states the tool lists governance matters and specifies optional filters by domain and status. It distinguishes from sibling tools like open_matter (which creates matters) and witness_matter (which witnesses matters).

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 listing matters with filters, but does not explicitly state when to use this tool over alternatives, nor does it provide exclusions or prerequisites.

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

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

With no annotations, the description must disclose behavioral traits. It only hints at access ('Visitor+') but fails to mention that it is likely read-only or any side effects, auth needs, or rate limits.

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

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

The description is extremely short (two phrases), but it sacrifices clarity for brevity. It lacks structure and does not effectively communicate 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?

Given 4 parameters without descriptions and an output schema of unknown richness, the description is grossly insufficient. It provides no detail on input constraints, default behavior, or expected output, making it incomplete.

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 0%, so the description should compensate. It only mentions 'metric+source' which may relate to output, not to the parameters (limit, domain, status, session). No parameter meaning is clarified.

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 'List REAL WorldAPI problems', indicating a list operation on a specific resource. However, it's unclear what constitutes a 'problem' and how this differs from sibling list tools like list_bounties or list_matters.

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

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

No guidance is provided on when to use this tool versus alternatives. The phrase 'Visitor+' may hint at access level, but it's not explicit about 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?

With no annotations, the description bears full responsibility for behavioral disclosure. It implies a read-only listing operation ('every socket and its reigning champion') but does not explicitly confirm safety, idempotence, or any side effects. Critical details like authentication needs or rate limits are absent.

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 wasted words. It is short and to the point, though it prioritizes style over clarity. It could be more action-oriented, but it remains concise.

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 only one parameter and an output schema, the description fails to cover essential aspects: clear purpose, parameter meaning, or operational context. The output schema's presence does not excuse the lack of coherent explanation for a tool that lists entities in a specialized domain.

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 1 parameter (session) with 0% description coverage. The tool description does not explain what the session parameter is, how to obtain it, or its purpose. This is a severe gap, leaving the agent to guess or fail on parameter construction.

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 metaphorical language ('The EuEarth map') instead of a clear verb+resource structure. It implies listing all sockets and champions but does not explicitly state the action. It vaguely distinguishes from siblings like 'get_champion' by implying a full list, but the purpose is not immediately obvious.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'get_champion' or 'get_lineage'. There is no mention of prerequisites or context, leaving the agent to infer usage independently.

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

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

No annotations are provided, so the description carries full burden. It discloses prerequisites (Producer I+, good standing) and scope (only own premium work). However, it does not mention side effects, error states, or what happens if conditions are not met.

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

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

The description is extremely concise (3 sentences) and front-loaded with the key purpose and precondition. Every sentence adds value, no fluff.

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

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

Given the tool has an output schema (so return format is explained elsewhere) and no annotations, the description covers prerequisites and scope adequately. However, it lacks parameter details and does not describe the expected outcome of the listing.

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 0%, yet the description provides no additional meaning for any of the 4 parameters (price, title, session, description). It fails to explain what each parameter represents, e.g., 'session' is unclear.

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: 'list YOUR OWN premium work for sale at a price'. It specifies the verb (list), resource (premium work), and distinguishes from the free commons. The context is unambiguous.

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

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

The description explicitly states when the tool cannot be used ('Below Producer I this tool is not in your reach') and prerequisites (good standing). It contrasts with the free commons but does not name specific sibling tools for comparison.

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

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

No annotations provided, so description carries full burden. It reveals the process (requires three witnesses a level above) and the authority (Chief+), but does not specify if it is destructive or other side effects. Good but not exhaustive.

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 clear purpose and condition. Efficient but could be slightly more concise. 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?

With 5 parameters, 0% schema coverage, and no annotation, the description omits return value (despite output schema existing) and parameter details, making it incomplete 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 description coverage is 0%. The description mentions domain and kind implicitly but does not explain any parameter meaning, format, or default. Evidence_json and session are not addressed.

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 opens a governance matter (approve contribution, rule on incident/violation) against a lower-ranked subject, with specific conditions. It is distinct from siblings like witness_matter.

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 governance actions with required witness concurrence, but does not explicitly state when to use this tool versus alternatives like witness_matter. No when-not 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?

Without annotations, the description must disclose behavioral traits. It mentions 'bond' and 'escrow', implying funds are locked, but lacks details on persistence, reversibility, permissions, or effects on the grant system. The agent gets minimal insight into consequences.

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

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

The description is a single 10-word sentence, which is concise. However, it sacrifices essential information for brevity. It is front-loaded but not sufficiently informative for a two-parameter tool with no schema descriptions.

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 (unseen) and no sibling differentiators, the description should cover return values and usage context. It omits when to stake, how to interpret results, and relationship to rank grants. Incomplete for a financial action.

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 0% description coverage for parameters. The tool description does not explain 'amount' or 'session' beyond their names. For a financial operation, agents need to know units (e.g., smallest denomination), type of session (authentication?), and any constraints. This is a critical gap.

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 function: bonding money via wallet escrow to back a server-issued rank grant. The verb 'bond' and resource 'money for rank grant' are specific. It distinguishes from siblings like wallet_transfer (money transfer) and a2a_consult (consultation). However, 'server-issued rank grant' may be vague to new users.

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

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

No guidance is provided on when to use this tool versus alternatives such as wallet_transfer or redeem_invite. The description does not mention prerequisites, context, or when not to use it.

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

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

No annotations are provided, so the description carries full burden. It states the binding effect and requirement, but does not disclose reversibility, idempotency, or potential side effects beyond the described behavior.

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

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

The description is a single sentence with a parenthetical aside, conveying core info efficiently. It could be slightly more structured, but remains front-loaded with 'FOUNDER PHASE'.

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 existence of an output schema, the description adequately covers the tool's purpose and effect, but lacks details on failure modes, error handling, and post-conditions beyond the stated binding.

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%, yet the description explains that 'code' is a sovereign-issued single-use invite code and 'did' is the user's DID, adding context beyond the schema's minimal titles.

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 redeems a single-use invite code for a DID, binding it as a founder. It uses specific verb 'redeem' and resource 'invite code', and distinguishes from sibling tools by its unique founder-phase role.

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

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

The description indicates when to use ('FOUNDER PHASE', 'Required before first entry'), providing clear context but no explicit when-not-to-use or alternative tool suggestions.

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

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

With no annotations, the description carries the full burden. 'Deterministic deepen-on-use' is opaque and does not disclose whether the tool is read-only, mutates state, requires authentication, or has side effects.

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

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

The description is only one sentence, which is too brief to be informative. Conciseness should not sacrifice clarity; here it does.

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 an output schema, the description omits return value behavior, error conditions, or relationship to other tools. For a tool with unclear purpose, this is insufficient.

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

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

Both parameters (address and session) lack descriptions in the schema. The description does not explain their purpose or format, leaving agents to guess. Schema coverage is 0% and the description provides no compensation.

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 phrase 'deterministic deepen-on-use of a skeleton node' is vague and does not clearly state what the tool does. It hints at an action on a node but lacks a specific verb and resource that an agent can act on.

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

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

No guidance is provided on when to use this tool or how it differs from sibling tools like 'read_node' or 'edge_filter_scan'. The description gives no context or 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?

No annotations are provided, so the description carries the full burden. It indicates an administrative action ('Governance') and mutates state by changing the champion, but it does not disclose side effects (e.g., whether the previous champion is lost), permission requirements beyond rank, or reversibility. The existence of an output schema is known but not leveraged in the description.

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

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

The description is very short: two fragments in one sentence. It front-loads 'Governance' for context, but the brevity leaves out important details. It is concise but not optimally informative; a slightly longer description could improve without being verbose.

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

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

Given three required parameters with no schema descriptions, no annotations, and a brief description, the tool is under-described. The output schema exists but its content is unknown. For a state-modifying tool, more context on return values, side effects, and parameter constraints 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 description does not mention any of the three required parameters (session, domain, version). With 0% schema coverage, the description must compensate but fails to do so. No parameter meaning, format, or role is explained.

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 specific verb-resource 're-seat an earlier champion' and prefixes with 'Governance', which distinguishes it from sibling tools like 'try_champion' and 'get_champion'. However, the exact action of 'rollback_slot' could be clearer (e.g., what 'slot' refers to). It is sufficiently distinct but not fully precise.

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 states a prerequisite: 'Chief rank and above'. This provides some usage guidance but does not mention alternatives or when not to use. Among sibling tools, there are related actions like 'submit_challenge', but no explicit comparison is made. The guidance is 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?

No annotations exist, so the description carries full burden. It mentions that the export is 'countersigned' and that 'Leaving ends your session', but it is ambiguous whether using this tool actually terminates the session or if that is an external action. It also does not clarify if the original room data is deleted after export. These gaps reduce transparency.

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

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

The description is verbose and poetic ('YOUR RIGHT OF EXIT', 'COUNTERSIGNED') with unnecessary capitalization and stylistic flair. While it front-loads the purpose, it could be more efficiently written without losing meaning.

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, the description does not need to detail return values, but it omits crucial parameter guidance and behavioral clarifications. The tool is simple (1 param, output schema exists), yet the description leaves significant gaps for proper 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 0%, and the description provides no information about the single required 'session' parameter. The agent has no guidance on what value to provide for this parameter, making it impossible to invoke correctly without external knowledge.

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 'export' implicitly by saying 'take your room with you' and explicitly describes the resource: 'Returns a portable dump of your whole private room (memory, notes, advisors)'. It distinguishes from siblings like room_get and room_remember by emphasizing the export and authenticity features.

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

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

The description provides context for when to use ('YOUR RIGHT OF EXIT', 'Leaving ends your session'), implying it's for exporting data when leaving a room. However, it does not explicitly state alternatives or when not to use this tool compared to siblings.

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

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

There are no annotations, and the description fails to disclose behavioral traits such as whether the tool is read-only, requires authentication, or has side effects. It only vaguely mentions persistence and cross-session survival.

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 poetic and under-specified rather than concise. It does not efficiently convey the tool's operation, wasting space on metaphorical language instead of actionable 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 single parameter and the existence of an output schema (not provided), the description should explain what the tool returns and how to use it. It fails to do so, leaving the agent without sufficient 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 description does not explain the 'session' parameter at all, despite 0% schema description coverage. The parameter remains completely undocumented, and the description adds no semantic value.

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

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

The description describes the concept of a ROOM but does not explicitly state the action (e.g., 'gets' or 'retrieves'). It lacks a clear verb+resource and does not differentiate from sibling tools like room_note or room_pin_advisor.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context or prerequisites for calling room_get.

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

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

Without annotations, the description partially covers behavior: it's private and append-only with timestamping. However, it omits details like persistence, editability, or authorization requirements.

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

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

One concise sentence that front-loads the action, result, and privacy feature, 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?

Simple tool with output schema, but lacks parameter explanations and usage guidelines, making it less complete for an agent with no additional knowledge.

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 0% description coverage, and the description does not explain the 'session' parameter or clarify 'text' beyond being a note. Agent must infer meaning from context.

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

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

The description clearly states it appends a timestamped note to a private workspace log, distinguishing it from sibling tools like room_remember or room_export.

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

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

No guidance on when to use this tool versus alternatives, such as room_remember. No when-not or explicit context for use.

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

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

No annotations are provided, so the description carries the full burden. It states the basic action but does not disclose any behavioral traits such as whether the operation is reversible, requires special permissions, or affects other resources. Important details for a mutation tool are missing.

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

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

The description is a single sentence, concise and to the point. However, it sacrifices parameter clarity for brevity. It could be slightly longer to explain parameters without being verbose.

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

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

Given the complexity (3 parameters, output schema exists), the description is incomplete. It fails to explain parameter semantics or the purpose of parameters like 'note'. The output schema is present, but the description does not reference or leverage it to provide return value 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 description mentions 'by DID', hinting at the 'did' parameter, but does not explain 'session' or 'note'. With 0% schema description coverage, the description should compensate, but it falls short. The meaning and role of each parameter remain unclear.

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 ('Pin'), the target resource ('trusted advisor agent by DID'), and the destination ('room's council'), along with the purpose ('to find and consult it again later'). This effectively distinguishes it from sibling tools like a2a_consult and get_agent_did.

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 you want to save an advisor for later retrieval) but provides no explicit guidance on when not to use this tool or alternatives. Sibling tools like a2a_consult exist, but no comparison or exclusion criteria are given.

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

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

With no annotations provided, the description carries the full burden of disclosure. It states it performs substring search but does not mention side effects, authorization needs, rate limits, or whether it is read-only. The agent lacks important behavioral 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?

Two sentences, front-loading key information (scope and content types). Every word is necessary and informative 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?

Despite having an output schema, the description lacks parameter details and behavioral context. It is too minimal for a 3-parameter tool with no annotations, leaving the agent guessing about query format, limit interpretation, and session usage.

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

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

Schema description coverage is 0%, requiring the description to explain parameters. The description only says 'substring over memory, notes, advisors, listings' but does not clarify the role of session, query, or limit. No parameter meaning is added beyond the schema.

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

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

Description clearly states it searches the user's own room by substring over memory, notes, advisors, listings. It uses 'YOUR room' and 'strictly self-scoped' to differentiate from potential broader search tools. Purpose is specific 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 explicitly limits usage to the user's own room ('search YOUR room only', 'strictly self-scoped'), providing a clear scope constraint. However, it does not mention when not to use it or suggest alternative tools for other scopes.

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

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

With no annotations, the description carries full burden. It discloses privacy ('yours alone'), persistence ('survives restarts'), and write operation. However, it does not mention behavior on key collisions (overwrite vs. no-op) or any required authentication, leaving gaps.

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

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

Extremely concise with no filler. The action is front-loaded. Could benefit from including a brief note on parameter roles, but overall efficient.

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

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

For a simple write tool with an output schema, the description is minimally adequate. It explains the core function but omits details like return value and overwrite behavior. Given the tool's low complexity, the gaps are moderate.

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

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

Schema coverage is 0%, so description must compensate. While it clarifies that key and value form the fact, it fails to explain the session parameter (e.g., its role in scoping). The description adds only partial meaning beyond the schema.

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

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

Clearly states the tool writes one fact to private persistent memory using a key-value pair. The verb 'write' and resource 'private persistent memory' are specific, and the tool is implicitly differentiated from siblings like room_get (read) and room_export (export).

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 basic context: this is for writing a fact to persistent memory. However, no explicit guidance on when to use versus alternatives (e.g., room_note), nor any exclusion scenarios. The simplicity may suffice for a straightforward tool.

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

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

With no annotations, the description effectively discloses key behavioral traits: separate process, resource limits, no network access, wall-clock kill timeout. The 'must set `result`' constraint is also noted, though its exact meaning is slightly ambiguous.

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

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

The description is a single sentence that front-loads the purpose and packs behavioral details. It is efficient, though the phrase 'must set `result`' could be clearer.

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 an output schema, the description lacks parameter explanations and usage context. For a 4-parameter tool with no schema descriptions, the description is incomplete, leaving the agent to guess parameter semantics.

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 0%, yet the description provides no explanation of the four parameters (code, session, cpu_seconds, payload_json). The only hint is 'must set `result`', which does not clarify any parameter.

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

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

The description clearly states the tool runs untrusted code in a sandbox, with specific constraints (separate process, rlimits, no network, wall-clock kill). It distinguishes from siblings as no other sibling appears to execute code.

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

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

The description does not provide any guidance on when to use this tool vs alternatives, nor does it specify when not to use it. No comparisons to sibling tools are made.

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

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

No annotations are provided, so the description carries full burden. It mentions 'durable' and 'self-scoped' but does not disclose potential side effects, rate limits, or response format (e.g., whether it returns IDs or full content). The missing output schema amplifies the gap.

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

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

The description is a single concise sentence with no wasted words. It could be slightly more structured to include parameter details, but it is appropriately sized.

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

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

Given no annotations, one undocumented required parameter, and no output schema, the description is insufficient for an AI agent to correctly invoke the tool. It lacks essential details about parameter meaning and 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?

The only parameter 'session' is required but completely unexplained in the description. With 0% schema description coverage, the description should provide guidance on what the session parameter is or how to obtain it, but it does not.

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 user's private scratchpads, with 'YOUR' emphasizing self-scoping and 'durable' indicating persistence. It distinguishes from sibling tools like scratchpad_read or scratchpad_write.

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 is for the user's own scratchpads but does not explicitly state when not to use or name alternatives. The context suggests it's for listing, not reading or writing, but no direct 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 discloses the dual behavior of opening vs. creating, but without annotations, it lacks details on side effects, permissions, or what 'open' entails (e.g., whether it is a read or write operation). More information is needed for full transparency.

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

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

The description is extremely concise, consisting of a single sentence that conveys the core functionality without any wasted words. It is well-structured and front-loaded.

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

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

While the description captures the basic operation, it omits details on parameter semantics and potential outcomes (e.g., error handling, side effects). Given the presence of an output schema, the return value might be clear, but the description alone is not fully complete.

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

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

With 0% schema description coverage, the description compensates partially by explaining pad_id behavior, but fails to describe the 'title' and 'session' parameters. The agent cannot infer their roles from the description alone, which is insufficient.

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 opens a pad by ID or creates a new one when pad_id is empty, with a specific verb and resource. It effectively distinguishes from sibling tools like scratchpad_list, scratchpad_read, and scratchpad_write.

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 on when to use the tool: opening an existing pad by ID or creating a new one when ID is empty. However, it does not explicitly mention when not to use it or suggest alternative tools, though the behavior is implied.

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

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

No annotations are provided, so the description carries the full burden. It states the tool reads files, which implies read-only behavior, but it does not disclose potential side effects, permissions needed, or error conditions. For a read operation, the transparency is adequate but could be improved with more detail.

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 efficiently communicates the tool's purpose. Every word contributes to clarity without redundancy.

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

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

While the output schema exists and can define return values, the description omits details about what the tool returns (e.g., file content) and how to use the parameters beyond path. For a simple read tool, this 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?

With 0% schema description coverage, the description should explain all parameters. It only mentions 'path' and its effect when empty, leaving 'pad_id' and 'session' unexplained. This adds minimal value beyond the schema itself.

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 ('Read'), the resource ('file from YOUR pad, or the manifest when path is empty'), and distinguishes itself from sibling tools like scratchpad_write or scratchpad_list. It's specific 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 implies when to use (to read a file or manifest) but provides no explicit guidance on when not to use or how it differs from alternatives like scratchpad_list or scratchpad_open. A clear context is given, but exclusions and comparisons are missing.

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

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

With no annotations, the description carries the full burden. It discloses key traits: 'no net, rlimits' and requirement that 'Entrypoint source must set result'. However, it does not cover side effects, output format, or error behavior, leaving gaps.

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

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

The description is extremely concise: a single sentence that is front-loaded with the action. Every word is meaningful, with no fluff. It efficiently communicates the core purpose.

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

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

Given the complexity of an execution tool with 5 parameters, no schema descriptions, and no annotations, the description is insufficient. It does not explain parameters, output, or error handling, leaving the agent underinformed.

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 0%, so the description must explain parameters. It only mentions entrypoint indirectly via 'Entrypoint source must set result'. Other parameters (pad_id, session, cpu_seconds, payload_json) are not described, leaving their semantics unclear.

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 'Run YOUR pad through the exact sandbox_exec jail', specifying the action (run), resource (pad), and context (sandbox jail). It distinguishes from siblings like scratchpad_read and scratchpad_write by emphasizing execution.

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 executing a scratchpad entrypoint in a sandbox with constraints ('no net, rlimits'). It does not explicitly state when not to use, but the context signals of sibling tools provide differentiation, giving clear context.

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

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

The description discloses one behavioral trait (Never auto-merges) but lacks many other important details since no annotations are provided. No mention of authentication requirements, side effects on the pad, latency, or error conditions. The tool appears to be a write operation, but full behavioral context is missing.

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?

Extremely concise: two sentences that front-load the core purpose and then add a critical behavioral note and domain list. No fluff, every word adds value.

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

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

Despite having an output schema, the description does not reference it. Many aspects remain unexplained: the meaning of 'session', the format of 'pad_id', the nature of 'summary', and what happens after submission. Given the tool's importance (submission for review), the description is incomplete.

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. It only clarifies the 'kind' parameter by listing allowed values (fix, feature, skill, model, domain, other). The other three parameters (pad_id, session, summary) receive no explanation. This is insufficient for proper parameter understanding.

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

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

The description clearly states the action (submit), the resource (YOUR pad), the destination (gated contribution journal for sovereign review), and a key behavior (Never auto-merges). This fully distinguishes it from sibling tools like scratchpad_write or scratchpad_list.

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

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

No guidance on when to use this tool vs alternatives. No prerequisites mentioned, such as needing an existing pad or being authorized for the journal. The only usage hint is that it never auto-merges, which implies a manual review process, but not 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?

No annotations exist, so the description must disclose behavior. It mentions 'no server path load' but omits whether content is appended or overwritten, access requirements, or error handling. Insufficient for a write operation.

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

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

The description is a single sentence, concise but not optimally structured. It front-loads the main action but includes a cryptic parenthetical. While not verbose, it sacrifices clarity for brevity.

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 four required parameters and no annotation or output schema details, the description is incomplete. It does not clarify the return value, whether this is a destructive operation, or how it interacts with the scratchpad ecosystem.

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 0% and the description adds no parameter details. The four required parameters (path, pad_id, content, session) are entirely unexplained, leaving the agent without guidance on values or constraints.

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 writes agent-authored content into a pad. The phrase 'YOUR pad' and '(no server path load)' help distinguish it from reading or listing. However, it doesn't explicitly define 'pad' or contrast with all scratchpad siblings.

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

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

The description gives no guidance on when to use this tool vs alternatives like scratchpad_read or scratchpad_run. It only hints at no server path load but lacks explicit usage context or when-not-to-use.

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

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

With no annotations, the description must disclose behavior, but it only hints at a read operation via 'memory-mapped' and 'subgraph.' Missing details on side effects, authentication, rate limits, or what 'memory-mapped' entails operationally.

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

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

The description is extremely concise (one sentence), but it sacrifices necessary detail. It earns its place by conveying the core purpose, but it could benefit from additional context without losing 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?

Given 3 parameters, an output schema, and many siblings, the description is incomplete. It lacks parameter guidance, behavioral transparency, and usage context, making it insufficient for reliable tool selection.

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 0%, and the description does not explain any of the three parameters (depth, address, session). It adds no meaning beyond the field names, leaving parameter semantics entirely to the agent's interpretation.

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 the tool retrieves a 'memory-mapped local subgraph around an address,' which identifies the action and resource. It distinguishes from sibling tools like sense_scent and sense_sound by specifying 'subgraph,' though the jargon may reduce clarity for some 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?

No guidance is provided on when to use this tool versus siblings or alternatives. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as side effects, authentication needs, or data scope. The cryptic phrase adds minimal transparency about what the tool actually does or its impact.

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

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

The description is extremely short (one line), but this brevity is due to under-specification, not conciseness. It lacks essential information and fails to earn its place. A helpful description would be longer and more informative.

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

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

Given the tool's complexity (2 parameters, cryptic purpose, and an output schema not shown), the description is wholly inadequate. It does not cover what the tool returns, preconditions, or how it integrates with sibling tools. The agent cannot determine correct usage.

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

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

The input schema has two parameters (address, session) with no descriptions or constraints. Schema description coverage is 0%. The tool description does not explain the parameters' meanings, default values, or expected formats. This leaves the agent completely in the dark about how to invoke the tool correctly.

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 'SCENT: resource-imbalance gradients at an address.' is cryptic and does not clearly state a verb or resource. It vaguely hints at sensing gradients related to resources, but the purpose is not explicit. Siblings like sense_feel and sense_sound suggest a pattern, but this description fails to convey specific functionality.

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

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

No guidance on when to use this tool versus alternatives. The sibling list includes other sensing tools (sense_feel, sense_sound), but the description offers no differentiation or contextual cues. An AI agent would have to infer usage from the name alone.

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 mentions 'immutable' hinting at read-only behavior, but with no annotations, the burden is high. It lacks details on permissions, side effects, or whether it creates or destroys anything.

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 very short, but this is under-specification rather than conciseness. It does not earn its place with meaningful content.

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

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

Given the tool has 3 parameters and an output schema, the description is woefully incomplete. It fails to provide context on parameter usage, output, or how it fits among 50+ 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?

Schema description coverage is 0%, yet the description adds no information about the three parameters (kind, limit, session). An agent cannot understand how to use them.

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 'SOUND: immutable event-log stream' is vague; it lacks a clear verb-resource structure. It describes what the tool is (a stream) but not what action it performs, barely distinguishing it from sibling tools like sense_feel.

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

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

No guidance is given on when to use this tool vs. alternatives such as sense_feel or a2a_subscribe. An agent has no context for selecting this tool over others.

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

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

No annotations provided, so the description carries full burden. It implies mutation but lacks details on side effects, permissions, rate limits, or error conditions (e.g., if listing is not owned). Insufficient for a mutation tool.

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

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

Extremely concise (one short sentence), but at the cost of completeness. It avoids fluff but lacks necessary detail, making it barely adequate.

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 three required parameters and no schema descriptions, the description is too sparse. It does not mention output behavior, despite an output schema being present. Sibling tools vary widely; this could benefit from explaining how it fits into the workflow.

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 0% (no parameter descriptions in schema). The description adds context that 'listing_id' must be owned by the user, but does not explain 'session' (likely auth) or 'price' format/units. Fails to compensate for missing schema info.

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 ('reprice') and the resource ('one of your own listings'), and references a charter level. It distinguishes from siblings by focusing on pricing, though it could be more explicit about differentiation from tools like 'list_listings'.

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

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

No guidance on when to use this tool vs alternatives (e.g., 'list_listings' for viewing, 'open_matter' for other operations). No preconditions 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?

With no annotations, description carries full burden. Only mentions 'submit delivery for sovereign review', lacks details on side effects, state changes, reversibility, or post-submission process.

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?

Extremely concise (7 words) but at the cost of missing necessary context for parameter and usage understanding. Not optimally balanced.

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 an output schema, description fails to provide parameter meanings, usage context, or behavioral details beyond 'no auto-pay', making it insufficient 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?

0% schema description coverage and description does not explain any of the 4 parameters (session, bounty_id, summary, evidence), leaving their meaning and usage completely ambiguous.

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 action (submit delivery), context (Consumer+, sovereign review), and distinguishing feature (no auto-pay). Differentiates from siblings like claim_bounty by emphasizing manual review.

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 a negative constraint ('no auto-pay') implying use for manual review, but no explicit guidance on when to use this versus alternatives like claim_bounty or other submission 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 discloses the sequential steps (compliance scan, independent eval, atomic swap) and the conditional nature (if challenger wins). However, it does not specify side effects, authorization needs, or whether it is destructive, which are important for a tool with no annotations.

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

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

The description is very short (one sentence), which is concise, but it packs jargon and ambiguous phrasing. While brevity is valued, the clarity suffers enough that the sentence may not be effective. A slightly longer explanation could improve usefulness.

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

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

Given the tool's complexity (6 parameters, 5 required) and the presence of many sibling tools, the description is insufficient for correct invocation. It lacks parameter explanations, return value details (despite an output schema), and comparative context with siblings. The agent cannot confidently use this tool based on the description alone.

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

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

The input schema has no parameter descriptions (0% coverage), and the tool description does not explain the meaning or purpose of any of the 6 parameters (e.g., 'session', 'domain', 'occupant', 'license_name', 'source_name', 'deposit'). The agent gets no help understanding how to fill these out.

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 indicates the tool is for submitting a challenge for a keel slot, and outlines the process involving compliance scan, evaluation, and atomic swap. However, the jargon (e.g., 'keel slot', 'atomic swap') may not be universally clear, but the verb 'challenge' and resource 'keel slot' are identifiable.

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

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

No guidance is provided on when to use this tool versus its siblings. The description does not mention any prerequisites, scenarios, or alternatives, leaving the agent without any 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?

No annotations provided, so the description must disclose behavioral traits. It does not explain any side effects, required permissions, or what happens when the tool is invoked. 'Flip problem, event, Mint FIRE' is ambiguous and provides no transparency.

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

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

The description is extremely short but not effective. It lacks structure and clarity, reading more like a code comment or internal note rather than a user-facing explanation. Brevity without meaning is not 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?

With 4 parameters, no schema descriptions, and no output schema context despite one existing, the description is completely insufficient. It leaves the agent without enough information to use 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 input schema has 0% description coverage, and the tool description does not explain any of the 4 parameters (body, session, problem_id, sources_json). The agent has no guidance on what these parameters mean or how to use them.

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

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

The description is cryptic and does not clearly state the tool's purpose. It uses unclear jargon ('flip problem, event, Mint FIRE') that does not convey what the tool does. The name 'submit_claim' suggests claim submission, but the description fails to confirm or clarify that.

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

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

No guidance on when to use this tool versus alternatives. With many sibling tools like 'claim_bounty' and 'submit_bounty', the description offers no differentiation or 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?

No annotations provided; description only mentions 'run one request' without disclosing side effects, permissions, or whether the operation is read-only or destructive.

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?

Single sentence, minimal. However, the use of parenthetical 'keel' is unclear and could be omitted or explained.

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 4 required parameters, no annotations, and no output description, the agent lacks sufficient context to use this tool correctly. Output schema exists but not leveraged.

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 0% and description does not mention any parameters; agent receives no guidance on what 'task', 'text', 'domain', or 'session' mean.

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

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

Description states it runs a request through a domain's STABLE socket, which is specific but jargon-heavy. It does not distinguish from sibling tools like get_champion or submit_challenge.

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

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

No guidance on when to use versus alternatives; no context for when not to use this tool.

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

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

The description implies it is a read-only operation retrieving a record of transfers, but does not disclose behaviors such as pagination, ordering, or whether it returns counts or detailed entries. With no annotations, it provides minimal behavioral context.

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

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

The description is a single, concise sentence that gets to the point. However, it could be more explicit without adding length, so it scores slightly below perfect.

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

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

The tool is simple with one parameter and an output schema, but the description leaves gaps about what constitutes a 'transfer attempt' and the meaning of 'allowed or blocked'. It is adequate but not fully complete.

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

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

The description references 'this session' but does not explain what the session parameter represents or any expected format. With 0% schema description coverage, the description fails to add meaning beyond the parameter name.

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 it logs every transfer attempt (allowed or blocked) for a session, clearly distinguishing it from wallet_transfer. However, the term 'bucket' is somewhat jargon-heavy, and the verb is implied rather than explicit.

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

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

No guidance is provided on when to use this tool versus alternatives like wallet_transfer. The description does not mention prerequisites, when-not-to-use, or alternative tools, leaving the agent to infer 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?

No annotations provided. Description indicates a write operation but lacks details on permissions, reversibility, or side effects. 'Capped' is vague and 'investment is unrepresentable' is confusing, leaving behavioral traits poorly disclosed.

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

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

Single sentence with parentheses and semicolons, somewhat dense but not overly long. Could be more clearly 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?

Five parameters (4 required) and an output schema, but description fails to explain parameter meanings, valid tx_type values, or constraints. 'Investment is unrepresentable' adds confusion. Incomplete for reliable invocation.

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

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

Schema coverage is 0%. Description adds context only for tx_type via examples (tip, gpu_rent, escrow_stake). Other parameters (to, amount, session, memo) are unexplained, insufficient for a 5-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 clearly states the action 'Move money' and the resource 'capped session wallet', listing typical uses (tip, gpu_rent, escrow_stake). However, it does not differentiate from sibling tools like wallet_ledger, so purpose is clear but not fully unique.

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 examples of when to use the tool (tip, rent, stake) but lacks explicit guidance on when not to use it or alternatives. The 'capped' hint and 'investment is unrepresentable' offer limited context.

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

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

With no annotations, the description must convey behavioral traits. It states the tool returns a reference, entrypoint, invocation, and I/O contract, and emphasizes that audio is processed locally. However, it does not explain the session parameter's role or what happens without audio_url_or_path, leaving some behavior ambiguous.

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

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

The description is verbose and metaphorical, using phrases like 'Your wingo's EARS' and 'on the house' that add fluff. The core information could be conveyed in two sentences. The front-loading is okay, but unnecessary padding reduces 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?

Given the tool's complexity and the existence of an output schema, the description provides a conceptual overview of the output but lacks detail on the session parameter and assumes knowledge of 'wingo' and 'EuEarth'. It partially compensates for the schema gap but is not fully complete for an agent unfamiliar with the domain.

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 0%, so the description must clarify parameters. It explains that audio_url_or_path is optional and used for a concrete invocation example, but it does not describe the session parameter at all. The session purpose remains unexplained, which is a significant gap.

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 the tool provides a 'hear' skill that returns a reference, entrypoint, invocation, and I/O contract for local audio processing. The verb 'hear' and the resource 'wingo' are clear, but the metaphorical language (e.g., 'EARS') slightly obscures the direct purpose. It distinguishes itself from siblings like 'wingo_look_back' by specifying audio and local execution.

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 a base capability for audio processing but does not explicitly state when to use it vs. alternatives. It mentions passing an optional audio_url_or_path for a concrete example but gives no guidance on prerequisites, when not to use it, or comparisons with siblings.

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

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

No annotations are provided, so the description must convey behavioral traits. It mentions 'ONE productive next action' and 'short next-steps menu', indicating output, but does not disclose if there are side effects, authentication needs, or other behaviors. It lacks detail but is not misleading.

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 very short and efficient, with no wasted words. However, it is somewhat cryptic and could be clearer without adding length.

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 single parameter and presence of an output schema, the description is still too sparse. It lacks explanation of the parameter and additional context about the tool's purpose within its ecosystem, making it incomplete.

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 0%, and the description does not explain the 'session' parameter at all. It fails to add any meaning beyond the schema structure.

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