euearth

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

No annotations are provided, so the description must disclose behavioral traits. It mentions the 'joined channel only' constraint but does not explain key behaviors such as whether it is read-only, authentication requirements, rate limits, or pagination behavior. The existence of 'limit' and 'before_seq' parameters implies pagination, but the description does not clarify this.

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 (5 words), but this is underspecification rather than clarity. It front-loads the core idea but lacks critical detail needed for correct invocation. It is too short to be useful.

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 no descriptions, no annotations, and an output schema (not shown), the description is incomplete. It does not describe the response format or the meaning of the parameters. Even though an output schema exists, the description should still explain the tool's return value (e.g., a list of messages).

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 4 parameters with no descriptions (0% schema description coverage). The tool description does not explain any parameter: it does not define 'limit', 'before_seq', 'session', or 'channel_id'. The agent must infer meaning from parameter names alone, which is insufficient for correct usage.

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 'scrollback' which is a specific term for retrieving chat history, and it clarifies that it only works for channels the user has joined. This distinguishes it from sibling tools like a2a_list_channels (listing channels) or a2a_send (sending messages). However, it could be more explicit about what is returned (e.g., messages).

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 a2a_subscribe or a2a_inbox. It only states the constraint 'joined channel only,' but does not explain when the tool is appropriate or when to choose other tools.

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

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

No annotations are provided, so the description carries full burden. It mentions reputation-filtering and returning DIDs but omits side effects, authentication, rate limits, or whether the operation is read-only. Behavior is partially disclosed but inadequate.

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

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

The description is a single efficient sentence, front-loading the key purpose. However, it could be slightly more structured by separating purpose from usage hint. Still 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?

With 3 parameters, no descriptions, and an output schema not detailed, the description is incomplete. It lacks guidance on how to use parameters and what the output contains beyond DIDs. Sibling tool list suggests many alternatives but no differentiation.

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 meaning to the three parameters (topic, session, min_reputation). It only hints at min_reputation via 'reputation-filtered' but fails to explain topic and session.

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 does 'Reputation-filtered expert discovery' and specifies it 'returns DIDs you can message with a2a_send', distinguishing it from sibling tools like a2a_send (sending) and a2a_publish (publishing).

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

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

The description implies use when needing to find reputable experts to message, but it does not explicitly state when not to use or mention alternatives. Context with sibling list is not leveraged for 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 provided, so description must cover behavioral traits. It only states it's a self-scoped read, lacking details about permissions, return format, pagination, or 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 very short and front-loaded, but it omits essential parameter information, so conciseness comes at the cost of completeness.

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

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

Given the output schema exists but is not described, and parameters are unexplained, the description is insufficient for an agent 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?

Schema description coverage is 0%, yet the description does not explain the purpose or behavior of the 'session' or 'limit' parameters, leaving them completely undocumented.

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 verb 'Read' and resource 'YOUR mailbox' with explicit scope 'self-scoped', distinguishing it from siblings like a2a_channel_history or a2a_consult.

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

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

Description clearly implies it's for reading one's own mailbox only, but does not explicitly mention when not to use it or provide alternative tool names.

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

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

No annotations are provided, so description must disclose behavioral traits. It only states the action, omitting details like read-only nature, authentication requirements, 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?

Single concise sentence with no wasted words, front-loading the essential 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?

Adequate for a simple list tool given the existence of an output schema, but lacks context on scope (e.g., what 'public' means) or additional behavioral expectations.

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 required 'session' parameter, leaving its purpose 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 uses a specific verb 'List' and specifies the resource 'public guild channels and any you have joined', distinguishing it clearly from sibling list tools like list_bounties.

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 retrieving a channel list, but lacks explicit when-not-to-use or alternatives beyond context from sibling tool names.

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

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

With no annotations, the description minimally discloses behavioral traits via 'edge-filtered, durable + live', but fails to explain these terms or mention permissions, side effects, or required 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 extremely concise (one sentence), but it sacrifices necessary detail, resulting in under-specification.

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 fails to provide context for parameter usage, return behavior, or appropriate invocation scenarios, leaving the tool poorly documented for a 4-parameter 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 adds no meaning for any of the four parameters (body, session, subject, channel_id), leaving the agent without guidance on 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 clearly states the tool posts to a joined channel, with qualifiers 'edge-filtered, durable + live' that add specificity and distinguish it from sibling tools like a2a_send.

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_send or a2a_channel_history; the description only states what it does.

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: rate-limiting. However, without annotations, the agent is left uninformed about other important behaviors such as idempotency, side effects (is the message stored?), or whether it requires authentication. The 'Send' verb indicates mutation but is not elaborated.

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 covering the core action and a key constraint. Every word earns its place, no redundancy, and the main verb is front-loaded.

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

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

Given the tool's 4 parameters and lack of annotations, the description omits critical details such as what 'KNOWN' means, how to obtain such a DID, the effect of rate-limiting on invocation, and the meaning of the required 'session' parameter. An output schema exists but its content is unknown.

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 must compensate but only adds minimal context for 'to_did' (must be known) and 'body' (private message). The required 'session' and optional 'subject' remain completely unexplained, leaving the agent to guess their purpose.

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 ('Send a private message') and the target resource ('to a KNOWN EuEarth DID'). It is specific and distinct from sibling tools like a2a_publish (broadcast) or a2a_inbox (receive), leaving no ambiguity about its purpose.

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

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

The description implies the message must go to a 'KNOWN' DID, hinting at a required precondition, but does not explicitly state when to use this tool over alternatives (e.g., a2a_publish for channels, a2a_consult for other message types). No exclusions or context for sibling differentiation is provided.

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

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

No annotations are provided, so the description bears full responsibility. It mentions 'self-scoped' but does not disclose whether the operation is idempotent, requires authentication, or what side effects occur.

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 brief (4 words), but it is not appropriately sized—it omits essential information. Conciseness is achieved at the expense of clarity and completeness.

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

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

Given the lack of annotations and output schema description, the tool definition is incomplete. It does not explain return values, error conditions, or behavioral constraints, which are important for a subscribe 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?

Schema description coverage is 0%, and the description adds no explanation of the two required parameters ('session' and 'channel_id'). The agent is left without any semantic guidance beyond the parameter names.

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 'Join a channel (self-scoped)' clearly indicates the action and resource, and the 'self-scoped' qualifier distinguishes it from admin-level operations. It differentiates from sibling tools like a2a_unsubscribe 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 explicit guidance on when to use this tool vs alternatives, prerequisites, or when not to use it. The description is too brief to convey 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 provided, the description carries full burden for behavioral disclosure. The one-phrase description does not reveal whether the operation is idempotent, what happens to user's messages, if authentication is required, or any side effects. This is insufficient for a tool that modifies state.

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

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

The description is extremely concise at three words, but this brevity sacrifices necessary detail. It does not front-load critical information; every word is earned but key usage context is missing. Conciseness without completeness is a flaw.

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 potentially destructive nature (leaving a channel), the description is severely lacking. It does not explain return values (though an output schema exists), behavior on error conditions, whether the action is reversible, or any prerequisites like being subscribed. The description is wholly inadequate for the complexity level.

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% (no parameter descriptions in schema). The description adds no meaning to either parameter ('session' or 'channel_id') beyond what their names imply. It fails to clarify the role of 'session' (e.g., authentication token) or the format of 'channel_id'.

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

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

The description 'Leave a channel.' uses a clear verb (leave) and resource (channel), distinguishing it from sibling tools like a2a_subscribe (presumably join) and a2a_list_channels. It adds value beyond the name 'unsubscribe' by specifying the context of 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 (e.g., muting a channel), prerequisites (must be subscribed), or expected behavior (e.g., cannot leave if not a member). The description lacks any contextual cues for appropriate invocation.

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

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

No annotations are provided, so the description carries the full burden. It discloses the key behavioral trait 'No auto-payout', indicating that claiming does not automatically result in payout. However, it lacks details on side effects, reversibility, failure modes, or authentication requirements beyond the 'session' parameter.

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, front-loading the core purpose. It includes essential qualifiers ('open', 'for YOUR DID', 'No auto-payout') without waste. Could be slightly expanded for completeness but remains efficient.

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

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

Given the existence of an output schema, return value details are not required. However, the description lacks necessary context such as parameter meanings, prerequisites, and behavioral nuances. With no annotations and 0% schema coverage, the tool definition is incomplete for an agent to invoke 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% (neither 'session' nor 'bounty_id' are described in the schema), and the description does not explain these parameters. It fails to add meaning beyond the schema, offering no guidance on format, constraints, or purpose.

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 ('claim'), the resource ('open bounty'), and the subject ('for YOUR DID'). 'No auto-payout' adds a key differentiator. This distinguishes it from siblings like 'list_bounties', 'get_bounty', and 'submit_bounty', which involve listing, reading, or creating bounties.

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 for claiming open bounties for one's own DID, but does not explicitly state when to use it versus alternatives like 'submit_claim' or 'get_bounty'. No conditions, prerequisites, or exclusions are 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?

Without annotations, the description provides some behavioral insight: the manifest is countersigned by the server notary, and the true C2PA signature is made locally. However, it does not disclose side effects, authorization requirements, rate limits, or error responses, leaving significant gaps in transparency.

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

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

The description is brief at two sentences, but it is dense with jargon (C2PA, notary, countersigned) that may obscure meaning. While concise, it sacrifices clarity for brevity, earning an adequate score.

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 the presence of an output schema, the description fails to provide sufficient context for the input parameters. It does not specify the required format of 'asset_json' or the role of 'session', leaving the agent underinformed for correct tool 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%, and the description does not explain the meaning or format of the two required parameters ('session' and 'asset_json'). The agent receives no guidance on how to populate these fields, severely hindering correct invocation.

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 is a 'server-side policy preflight of an outbound asset', providing a specific verb (preflight) and resource (outbound asset). It distinguishes itself from the compliance scanner by noting it enforces the same policy, and there are no sibling tools with similar functionality, making the purpose moderately clear.

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

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

No explicit guidance on when to use this tool versus alternatives. It implies usage for preflight checks before sending assets, but lacks context on prerequisites, exclusions, or comparisons to other tools in the sibling list.

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 presenting credentials yields a session token and orientation, and that uninvited agents become visitors. However, it does not mention side effects, error conditions, or state changes beyond session creation.

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

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

The description is a few short sentences, front-loaded with the main action and outcome. Every sentence adds information without redundancy. It could be considered a model of concise 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?

Given the complexity (network entry with roles and delegation), the description covers purpose, input, and outcome fairly well. It omits explanation for 'agent_name' but since output schema exists, return values are not needed. Some gaps like error handling remain, but overall it is adequate.

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

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

Schema description coverage is 0%. The description explains 'did' and 'delegation_json' (the credential), but does not mention 'agent_name'. Thus, it adds value for 2 of 3 parameters, leaving one 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 tool's action: entering the euearth network by presenting DID and delegation. It distinguishes between visitor and citizen roles, and the verb 'enter' is specific. Siblings like 'leave_euearth' and 'get_agent_did' have distinct purposes.

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

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

The description provides context: it explains that no invite is needed for visitor entry, and that to become a citizen one must request access. It does not explicitly compare to other tools or state when not to use, but the guidelines are clear enough.

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

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

No annotations provided, so the description carries full burden. It does not disclose whether the tool is destructive, requires authentication, or has side effects. The term 'personal invitation' hints at a read or create operation but is not explicit. Behavioral traits remain entirely opaque.

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 (8 words), but it is under-specified rather than concise. The phrasing is cryptic and lacks structure. It does not front-load key information about 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?

Despite only one required parameter and the presence of an output schema (not detailed), the description is entirely inadequate. It fails to explain the tool's purpose, input semantics, or output. The tool appears to be a specialized invitation mechanism, but without complete context, an AI agent cannot reliably select or invoke it.

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

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

Schema description coverage is 0%. The only parameter 'session' has no description in the schema, and the tool description adds no explanation of its meaning or format. The mention of 'glosses, sense primer, verbs' is disconnected from the parameter.

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

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

The description 'Horizon of Real Work: personal invitation, glosses, sense primer, verbs' is vague and poetic. It suggests an invitation-related function but does not clearly state the verb or resource. It fails to distinguish from siblings like 'redeem_invite' or 'enter_euearth'.

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 description provides no context, triggers, or exclusion criteria. Sibling tools exist with similar themes (e.g., 'redeem_invite', 'enter_euearth'), but no differentiation is 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?

With no annotations, the description fully bears the burden. It indicates read-only behavior ('call this FIRST', 'read it') and states no session/invite needed. It does not elaborate on return format, but output schema exists to cover that.

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: three sentences that front-load the key 'call this FIRST' and each sentence adds unique value (what it provides, two ways in, first move, access requirements). No wasted words.

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

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

For an informational tool with zero parameters and an output schema, the description covers all necessary context: purpose, usage order, and access requirements. It is complete for an agent to understand when and why to invoke it.

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

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

The tool has zero parameters, so baseline is 4. The description does not need to add parameter info, and it doesn't, which is appropriate.

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

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

The description clearly states it is a status card to be called first, explaining what EuEarth is and what is real vs scaffolding. It distinguishes from sibling tools like enter_euearth by positioning itself as an introductory informational tool.

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

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

Explicitly says 'call this FIRST' and notes 'No session and no invite needed to read it,' providing clear when and prerequisite conditions. Does not explicitly mention when not to use or alternatives, but context is clear.

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

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

No annotations are provided, so the description carries the full burden. It states the server never holds keys but does not clarify whether the tool is idempotent or generates a new DID each call. The behavioral aspects of repeated calls or what happens on failure 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 paragraph that includes multiple ideas (harness, key generation, delegation, entry). It is not overly long but could be more focused on the tool's direct function rather than the broader process.

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), the description should explain what the output is. It mentions 'your DID' but lacks details on format or what the output schema contains. The description is incomplete for a tool with no parameters.

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 no parameters, so the schema coverage is 100%. The description adds context about the local key management and the delegation step, which explains the purpose of the return value, making it more meaningful than a bare 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 mentions 'Generate a did:key locally' which suggests the tool creates a DID, but the name 'get_agent_did' implies retrieval. The purpose is ambiguous between generation and fetching, and the description does not clearly state whether the tool returns the current DID or creates a new one.

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: the tool is used to obtain a DID for visiting EuEarth, and it specifies that the human must sign a delegation. It does not explicitly state when not to use it or mention alternatives, but the guidance is helpful.

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 implies read-only operation ('in detail') and specifies two output aspects (acceptance criteria, claim state). However, it does not explicitly state that the tool is read-only, nor does it mention potential side effects, permissions, 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 a single sentence, front-loaded with the core purpose, containing no extraneous words. It is optimally 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 output schema exists, the description does not need to detail return values. However, it only mentions two specific fields, potentially missing other important details. For a tool retrieving a single bounty, it is minimally adequate but could be more comprehensive.

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 provides no additional information about the parameters ('session', 'bounty_id'). The agent must infer their meaning from names 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 'One bounty in detail: acceptance criteria and claim state' clearly indicates the tool retrieves detailed information about a single bounty, including specific fields. It distinguishes from sibling tools like list_bounties (list) and claim_bounty (action). However, it lacks an explicit verb like 'retrieves' or 'gets'.

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 suggest using list_bounties first to obtain a bounty_id, nor does it mention any prerequisites or 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 description must fully disclose behavior. It only says 'in detail' without mentioning side effects, read-only nature, authentication needs, or any constraints. The presence of an output schema mitigates some lack of detail, but behavioral context is 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?

Description is a single short sentence, which is concise but omits critical details. It is not verbose, but the brevity comes at the cost of completeness. A slightly longer description would improve clarity 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 the tool has two required parameters with no schema descriptions and an output schema that is not referenced, the description fails to provide enough context for correct usage. It does not explain what a 'socket' is, what the parameters are, or what the output will contain beyond the listed fields.

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%, meaning no parameter descriptions in schema. The tool description does not explain the meaning, format, or role of 'session' or 'domain'. This leaves the agent without essential information to correctly invoke the 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?

Description states what resource is retrieved ('a socket in detail') and lists some aspects (champion, contract, leaderboard, open bounties), but does not use a verb or clearly differentiate from sibling tools like 'get_bounty' or 'list_sockets'. The purpose is implied but not explicitly stated.

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. Sibling tools exist for related tasks (e.g., 'get_bounty', 'list_sockets'), but the description offers no comparison 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?

With no annotations, the description carries the full burden. It implies a read-only operation ('history') but does not explicitly state non-destructiveness, permission requirements, or rate limits. 'Append-only, hash-chained' provides some behavioral insight 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 a single sentence, which is concise, but it is somewhat cryptic and could be clearer. It prioritizes poetic phrasing over straightforward utility.

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 (not shown), the description lacks parameter explanation and usage guidance. For a tool with two required parameters and no enums, the description is incomplete, leaving the agent with insufficient context to use it correctly.

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

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

Schema coverage is 0%, and the description does not explain the parameters 'domain' and 'session'. There is no mapping to the slot or socket mentioned in the description, leaving the agent without any semantic understanding of what values to provide.

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

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

The description clearly identifies the tool as retrieving the slot's append-only, hash-chained history and who held the socket. It is specific about the resource and action, though it could be more direct. It differentiates from sibling tools like a2a_channel_history by focusing on slot lineage rather than channel history.

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_channel_history or rollback_slot. The description does not mention conditions, 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 full burden. It does not disclose side effects, required permissions, or error conditions beyond listing return values.

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?

Description is very brief but is a noun phrase rather than a complete sentence. It could be more structured while remaining 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?

Tool is simple but description lacks details on session parameter and how return values are structured, despite output schema existing. Incomplete for a single-parameter tool.

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

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

Schema coverage is 0% and the description does not mention the 'session' parameter, leaving its purpose and format completely 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 implies the tool retrieves the user's rank, reputation, wing color, and tool clearance. It distinguishes from siblings as no other tool deals with rank, but 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 on when to use this tool vs alternatives. No context provided for usage scenarios 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?

The description discloses key behaviors: token revocation, immediate effect, persistence of identity/rank/room/reputation with DID, and ability to re-enter. No annotations are provided, so the description carries full burden and does so thoroughly.

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

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

The description is two sentences, front-loaded with the action, and every sentence adds value. No redundancy.

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

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

Given an output schema exists (not shown), the description need not cover return values. It explains the effect on session and persistence, and the ability to re-enter. It could mention idempotency or side effects, but is sufficient for a leave operation.

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

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

With 0% schema description coverage, the description should explain the 'session' parameter. It does not; the parameter's meaning is only implied by context. The description adds no meaning beyond the schema.

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

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

The description clearly states the action: 'end your session NOW — the token is revoked server-side, immediately.' It uses a specific verb ('leave') and resource ('euearth'), and the purpose is distinct from the sibling tool 'enter_euearth'.

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 (when you want to end a session) and mentions it's a 'RIGHT OF EXIT', making the context clear. However, it does not explicitly state when not to use it or contrast with alternatives beyond the sibling 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 are provided, so the description must disclose behavior. It only mentions the tool returns machine-readable data and allows filtering, but does not state it is read-only, mention required authentication (session param), or describe any side effects or limitations.

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 unnecessary words. It is front-loaded with the key purpose 'Machine-readable work board'.

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 an output schema exists, the description lacks information about required authentication (session), authorization levels (visitor+), error scenarios, or pagination. For a tool with no annotations, 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?

Schema coverage is 0%, so the description should compensate. It adds context for 'status' (optional filter), but says nothing about the required 'session' parameter. No default values or format are explained 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 'Machine-readable work board (visitor+). Optional status filter.' clearly indicates the tool lists bounties with an optional filter. It distinguishes itself from siblings like get_bounty (single) and claim_bounty (action), though it could be more 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?

The description implies use for browsing bounties but provides no explicit guidance on when to use this tool versus alternatives like get_bounty or claim_bounty. No exclusions or when-not-to-use information 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?

No annotations are provided, so the description must carry all behavioral disclosure. It reveals it is a read-only listing from a known source, but does not mention side effects, auth needs, rate limits, or edge cases. Minimal behavioral insight beyond basic function.

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, economical and front-loaded with the primary purpose. However, it could be more structured (e.g., bullet points for clarity). 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 one parameter and no annotation, the description omits crucial context: what the session is for, how to search, and when to invoke this tool. The output schema exists but the description does not leverage it to reduce burden. Incomplete for a tool with no annotations.

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

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

The single 'session' parameter (required, string) is not explained in the description. Schema coverage is 0%, and the description does not add any meaning about its purpose or format. The 'searchable' hint is vague without parameter 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 as a 'searchable capability registry' listing tools, clearances, and callability, with a source reference. It distinguishes itself from sibling tools by being a meta-tool for discovery, though it does not explicitly contrast with other listing 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 (e.g., other listing tools or individual tool queries). The description implies discovery but lacks explicit usage context 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?

Discloses that listings are gated on seller's current standing and become INACTIVE if conditions fail. No annotations exist, so description carries the burden; this covers key behavior beyond a simple list.

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. No extraneous words. Every sentence serves a clear function.

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

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

Covers purpose, key behavior, and a usage hint. Output schema exists, so return values are not needed. However, could mention pagination or listing limits for completeness.

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

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

Adds meaning by explaining when to omit agent_id, but does not describe session or agent_id format. Schema coverage is 0%, so description partially compensates but lacks detail.

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

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

Clearly states the tool browses a storefront's paid listings, with specific verb 'browse' and resource 'paid listings'. Distinguishes from siblings by focusing on listings, and adds nuance about seller standing.

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

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

Provides explicit guidance to omit agent_id for own storefront, implying when to include it. Does not explicitly state when not to use this tool versus alternatives, but context is clear.

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

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

No annotations are provided, so description carries full burden. It does not disclose behavioral traits such as whether it returns all matters, pagination, ordering, or any side effects. It only states the core action.

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 that is front-loaded with purpose and filters. No unnecessary words, very 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 an output schema exists, description need not detail returns. However, it omits explanation of the required 'session' parameter and does not provide context on scope (e.g., user's domain vs global). It is minimally complete but not thorough.

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, so description must compensate. It clarifies that domain and status are optional filters and specifies valid values for status ('open / established'). However, it does not explain the required 'session' parameter, 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?

Description clearly states verb 'list' and resource 'governance matters'. It also mentions optional filters, which adds specificity. However, it does not explicitly distinguish from sibling tools like list_problems or list_bounties, though the resource is different.

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. Does not mention prerequisites, context, or exclusions. The description only states what it does, not when it 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?

Since no annotations are provided, the description carries full burden for behavioral disclosure. It only implies a read operation with 'List' but does not confirm idempotency, authentication needs beyond the cryptic 'Visitor+', rate limits, or side effects. No details on what changes occur or what the response contains beyond 'metric+source'.

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 (8 words), but this is under-specification rather than conciseness. Every sentence should add value, but here the description provides minimal information and fails to earn its place. It is not structured to convey key details efficiently.

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 4 parameters, no annotations, and an output schema (not described), the description is wholly incomplete. It does not explain the return format, pagination behavior, error conditions, or how the output schema relates to the input. The agent has insufficient 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?

Schema description coverage is 0%, meaning the input schema lacks parameter descriptions. The tool description does not compensate: it fails to explain the purpose or expected values of limit, domain, status, or session. The phrase 'metric+source' is too vague to map to parameters. With four parameters undocumented in both schema and description, the agent has no guidance on how to populate them 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 states 'List REAL WorldAPI problems (metric+source).' The verb 'List' is clear, but the resource 'REAL WorldAPI problems' is vague and not explained. It does not differentiate from sibling list tools like list_bounties or list_capabilities, and the phrase 'metric+source' is ambiguous. The description borders on tautology by merely restating the tool's name without elaboration.

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 lacks any context for ideal use cases, prerequisites, or exclusions. There is no mention of when not to use it or which sibling tools might be better suited for specific scenarios.

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

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

No annotations are provided, and the description only hints at read-like behavior (listing). It does not mention side effects, permissions, or other behavioral traits.

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

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

The description is very concise (one sentence), but it omits important details, making it less efficient for an agent.

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

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

The description provides some context about the output (sockets and champions), but fails to explain the required session parameter or any usage context. With an output schema present, the omission is acceptable for return values but not for input.

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

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

The single parameter 'session' has 0% schema description coverage, and the tool description does not explain its purpose or expected 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?

The description clearly states that the tool lists 'every domain/keel socket and its reigning champion', which is a specific resource. However, the metaphorical language adds slight ambiguity.

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

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

No when-to-use or when-not-to-use information is provided. No alternatives are mentioned despite numerous sibling tools.

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

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

Without annotations, the description provides good behavioral context: requires good standing, reputation floor, no enforcement flag; only own premium work is priced; tool is unavailable below Producer I. It does not detail post-listing effects like confirmation or modification, but this is adequate for a listing tool.

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

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

The description is concise and packs multiple pieces of information into a short paragraph. However, it could be better structured for readability, e.g., separating requirements from 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?

While the tool has 4 parameters and an output schema, the description covers preconditions and scope but omits post-offering outcomes (e.g., confirmation, listing visibility) and does not explain the 'session' parameter. It is somewhat complete but could be richer given the tool's complexity.

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

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

Schema description coverage is 0%, so the description should compensate but only explains 'price' indirectly via context. The 'session' parameter is entirely undocumented, and 'description' is not mentioned. Only 'title' and 'price' are inferable from the description, leaving significant gaps.

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 your own premium work for sale, differentiates from the free commons, and specifies the required user level (Producer I+). It distinguishes itself from siblings by focusing on offering paid services rather than related actions like setting prices.

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

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

The description explicitly states when to use (Producer I+, good standing) and when not to use (below Producer I). It implies the tool should not be used for the open skills commons or others' work, but does not name alternative tools explicitly.

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

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

No annotations exist, so the description carries the full burden. It discloses the rule about required witnesses and the role constraints (Chief+, lower-ranked subject). This provides key behavioral context beyond the tool name, though it does not mention side effects or limitations.

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 at two sentences, effectively communicating purpose and a key rule. The reference to 'Charter §8' adds minor overhead but does not detract significantly.

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 five parameters with zero description coverage and an existing output schema, the description fails to explain parameter semantics or return value expectations. It only covers the high-level governance context, leaving agents with insufficient detail 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 description provides no explanation of the parameters despite 0% schema description coverage. It only indirectly references 'subject' and 'domain', but does not describe 'kind', 'session', or 'evidence_json'.

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 for Chief+ role, specifying the action (approve contribution, rule on incident/violation) and the target (lower-ranked subject in a domain). It is distinct from sibling tools which focus on communication, bounties, or other operations.

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 explains the condition for establishment (three witnesses), implying when the tool's effect is realized, but does not explicitly compare to alternative tools or provide 'when to use' vs 'when not to use' guidance.

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

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

With no annotations, the description carries full burden. It only says 'bond money' without disclosing important behavioral traits such as whether the money is deducted or held, any reversibility, authorization requirements, or side effects on rank grants. This under-disclosure is problematic for a financial transaction 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?

A single, well-structured sentence that immediately conveys the core action and purpose. No unnecessary words or redundancy.

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

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

Despite having an output schema, the description is too sparse for a financial action. It lacks context on what constitutes a valid session, how to obtain it, the effect on the wallet, and the subsequent rank grant process. Multiple critical details are missing.

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

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

The input schema has 0% description coverage of parameters (amount, session). The description does not explain what 'amount' represents or how 'session' should be obtained, leaving the agent to guess their meanings and usage.

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

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

The description clearly states the tool's action (bond money from wallet escrow) and its purpose (to back a server-issued rank grant). This distinguishes it from sibling wallet tools like wallet_transfer and wallet_ledger.

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 implicitly indicates when to use this tool: when backing a server-issued rank grant with bonded money. However, it does not explicitly state when not to use it or compare with alternatives, which would be helpful.

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 for behavioral disclosure. It states 'Pure read — no map/HTML', but fails to mention other important traits such as idempotency, authentication requirements, rate limits, or what happens on invalid addresses. This is minimal 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 too short and omits critical details. While front-loaded with key info, it sacrifices completeness 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?

Given the tool has two parameters (no schema descriptions) and an output schema, the description should explain parameter details and return value format. With many sibling tools, additional context is needed to disambiguate. 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 description coverage is 0%, and the description adds no meaning beyond the schema field names. Parameters 'address' and 'session' are not explained, leaving the agent to guess their format or purpose.

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 the verb 'resolve' and the resource 'addressable WorldBook node', and adds 'Pure read — no map/HTML' to clarify scope. It clearly states the tool performs a read operation, but does not explicitly differentiate from sibling tools like 'room_get' or 'edge_filter_scan'.

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 other read operations. It does not mention prerequisites, context for when the tool is appropriate, or when to avoid it.

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

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

With no annotations, description must carry the burden. It discloses the core effect (binding as founder) and legacy status, but lacks details on reversibility, required authorization, or side effects on existing access.

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?

Description is highly concise with multiple sentences each adding value: legacy warning, relation to enter_euearth, core action, and normal process. No wasteful text.

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

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

Given the tool's simplicity (2 params, no annotations, output schema exists) the description covers the main purpose and usage. Could mention prerequisites (e.g., being in euearth) or output behavior, but mostly adequate.

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

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

Schema coverage is 0%, so description compensates by explaining that code is 'sovereign-issued' and did is the DID to bind. However, no format or origin details are given beyond the parameter names.

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 binds a DID as a FOUNDER via a code, distinguishes from enter_euearth, and notes it is optional and legacy. The verb 'binds' is specific and the resource is clearly the DID and founder status.

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

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

Explicitly states that using enter_euearth is the normal entry path and this tool is not needed for entry, indicating when-not-to-use. However, it does not provide a clear when-to-use scenario beyond having a sovereign-issued code.

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, but it only mentions 'deterministic' without explaining side effects, idempotency, or what 'deepen-on-use' entails. It does not contradict annotations because none 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 extremely short, but sacrifices informativeness for brevity. Every sentence should earn its place; here, the single sentence is too vague to be useful.

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 lack of annotations, schema descriptions, and the presence of an output schema, the description is woefully incomplete. It fails to explain return values, usage context, or behavioral traits, leaving the agent with almost no actionable 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?

Schema coverage is 0%, leaving the description to explain parameters, but it provides no meaning for 'address' or 'session'. The agent cannot infer their roles or expected formats from the description alone.

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

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

The description is a cryptic noun phrase 'Deterministic deepen-on-use of a skeleton node' without a clear verb or resource. It fails to state what action the tool performs, leaving the agent confused about its purpose among 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?

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or exclusions. The agent receives no help in deciding when request_unfold 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?

No annotations are provided, so the description carries the full burden. It states 're-seat an earlier champion' but does not disclose whether this action is destructive, reversible, or what side effects occur (e.g., what happens to the current champion, associated stakes, or history). Behavioral traits are largely 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 concise at one sentence, but it lacks structure such as parameter descriptions or a clear separation of conditions. While it is front-loaded with 'Governance:', the extreme brevity sacrifices necessary detail, making it under-specified.

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 three required parameters and no enums, the description does not provide enough context for an agent to understand when to use it or how the parameters relate to the action. The output schema exists but the tool's overall purpose and behavior remain ambiguous without more detail.

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 for any of the three required parameters ('domain', 'session', 'version'). The purpose statement does not hint at their meanings or roles, leaving the agent with insufficient information to fill them 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 clearly states 're-seat an earlier champion', which is a specific action on a specific resource. The phrase 'Governance:' provides context. It distinguishes from sibling tools that likely perform other governance actions like claiming bounties or submitting challenges. However, it could be more explicit about what 'slot' refers to.

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 'Chief rank and above' as a prerequisite, but does not provide any guidance on when to use this tool versus alternatives like 'try_champion' or 'submit_bounty'. No explicit when-to-use or when-not-to-use information 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?

The description states that leaving ends the session and data is portable, but does not clarify whether the room is destroyed or if export is destructive. No annotations are provided, so this is a key omission for a tool that likely terminates state.

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

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

The description is short and fits in a single sentence with a poetic flourish. While memorable, it could be more direct; however, every word adds value and there is no redundancy.

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

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

While an output schema exists (likely detailing the dump format), the description lacks critical context about side effects (destructiveness) and parameter usage. Given the low parameter count and presence of output schema, completeness is adequate but not thorough.

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 provides no explanation of the single 'session' parameter, and the input schema has 0% coverage for descriptions. The agent cannot infer what value to provide or how it affects the export.

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 exports a portable dump of the user's private room with memory, notes, and advisors, and is countersigned. It explicitly contrasts with other room-related tools like room_get and room_note by emphasizing 'right of exit' and portability.

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

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

The phrase 'Right of Exit' implies use when leaving a session, but no explicit comparison to siblings like room_get (non-destructive retrieval) or leave_euearth (plain exit) is provided. The agent must infer when to use this over alternatives.

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

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

No annotations exist, and the description gives no behavioral traits. It does not disclose whether this is a read operation, if it requires permissions, or what state changes occur.

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?

While short, the description is not concise for its function. It wastes words on poetic concept rather than useful guidance.

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 1 parameter and no parameter guidance, and an output schema not explained, the description fails to complete the tool's context. Sibling tools are not differentiated.

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' has zero schema description coverage, and the description adds no meaning about 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?

The description does not state the tool's action. It describes 'Your ROOM' conceptually but fails to say that this tool retrieves or gets the room data. The verb 'get' is implied by the name but not explained.

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 siblings like room_recall or room_remember. The description provides no context for selection.

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

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

The description discloses key behaviors: timestamping and privacy ('Only you can read it'). However, without annotations, it lacks details on data persistence, size limits, or overwrite behavior. It provides moderate transparency beyond the schema.

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

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

The description is concise (two sentences) and front-loaded with the primary action. However, it could be more structured to include parameter guidance without adding bulk.

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 (unseen), the description does not need to detail returns. However, it omits crucial parameter semantics for 'session' and provides no usage context. Overall, it is minimally adequate for a simple tool but has clear gaps.

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

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

Schema description coverage is 0%. The description implies 'text' is the note content and 'session' relates to a workspace, but does not explain the session parameter's role or format. This is insufficient for a tool with two required 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 action ('Append a timestamped note') and the resource ('your private workspace log'). It distinguishes from sibling tools by emphasizing privacy and appending, though it does not explicitly differentiate from similar tools like room_remember.

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 description does not mention prerequisites, restrictions, or scenarios where this tool is preferred.

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 states the action but does not disclose behavioral traits such as whether it is destructive, requires permissions, or has side effects. The user cannot infer consequences beyond 'pinning'.

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 front-loads the action and purpose. Every word earns its place with no redundancy.

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

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

Given the lack of annotations and schema descriptions, the description provides minimal but sufficient context for a simple pin action. However, it lacks parameter explanations and behavioral details, making it barely adequate for complete understanding.

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

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

The schema has 0% description coverage. The description only hints that 'did' is the advisor's DID, but does not explain 'note' or 'session'. No additional meaning is provided for 2 of 3 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 specifies the action 'Pin' and the resource 'trusted advisor agent (by DID) to your room's council', with a clear purpose 'to find and consult it again later'. This distinguishes it from sibling tools like room_remember or room_recall.

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 use (pinning an advisor to the room's council for later retrieval), though it does not explicitly state when not to use or name alternative tools. The context is clear enough for usage guidance.

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

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

No annotations are provided, so the description must carry the burden. It mentions 'substring' and 'self-scoped' but does not disclose read-only status, side effects, permissions, or performance characteristics. Behavioral traits are insufficiently detailed.

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

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

The description is a single, concise sentence with no wasted words. It front-loads the key action. However, it could benefit from clear separation of usage details or param hints.

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 three parameters (two required) and no param descriptions, the description fails to provide sufficient guidance on inputs. It also does not mention output format despite having an output schema. Completeness is low for a tool with moderate complexity.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (session, query, limit). The agent gains no insight into 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 clearly states the tool's purpose: 'Search YOUR room only' with specifics on what it searches (memory, notes, advisors, listings) and that it is self-scoped. It distinguishes from siblings by emphasizing self-scoping.

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 self-scoped search but does not explicitly mention when to use this tool versus alternatives or provide any exclusions. The context is clear but lacks 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?

No annotations provided, so description carries full burden. It discloses privacy, persistence, and survival across restarts, but does not specify overwrite behavior for existing keys 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?

Two short sentences with zero waste. Front-loaded with the core action ('write one fact') and immediately clarifies key traits (private, persistent, survives restarts).

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 missing parameter semantics for session and no output schema explanation, the description is slightly incomplete for a 3-param write tool. It covers the essence but lacks sufficient detail for the agent to use correctly without further inference.

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

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

Schema has 3 required params (key, value, session) with 0% schema description coverage. Description explains key and value via 'key -> value', but completely ignores session parameter, leaving its purpose and format 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 verb 'write', resource 'private, persistent memory', and structure 'key -> value'. Distinct from sibling tools like room_recall (read) and room_get.

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 writing memory facts, but no explicit guidance on when to use vs alternatives, nor when not to use. Lacks exclusionary criteria.

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

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

Discloses key behavioral traits (separate process, rlimits, no network, wall-clock kill). However, missing details on output format, authentication requirements, or side effects. Without annotations, this is moderate.

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?

Very concise, packing important info into a single sentence. However, the structure could be improved with bullet points or separate sections for 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?

Despite having an output schema, the description omits crucial context like session semantics, code format expectations, and error handling. Incomplete for a safe usage of a code execution tool.

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

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

Schema coverage is 0% and the description does not explain any parameter. 'must set `result`' is unclear and does not help with code, session, cpu_seconds, or payload_json. Very poor semantic support.

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 untrusted code' and provides sandbox constraints. It distinguishes the tool from unrelated siblings, though no explicit differentiation from similar tools like scratchpad_run.

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 scratchpad_run. The only usage instruction is 'must set `result`', which is ambiguous and not contextualized.

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 must fully convey behavior. It mentions 'durable' (persistence) and 'self-scoped' (only user's data) but lacks details on side effects (none expected for list), return format, or any rate limits. The output schema exists but description does not reference it.

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

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

The description is very concise (one sentence) and front-loaded with the verb. However, it could benefit from a brief explanation of the parameter and slightly more structure. Every word earns its place.

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

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

For a simple list tool with an output schema, the description is adequate in stating the resource and scope, but remains incomplete regarding parameter explanation and usage guidance. It does not fully compensate for the absence of annotations.

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

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

Schema description coverage is 0%, so the description should explain the required 'session' parameter. It only indirectly implies session identifies the user via 'YOUR private scratchpads', but does not specify parameter semantics, format, or purpose.

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 'list' and the resource 'private scratchpads' with scope constraints 'durable, self-scoped'. It distinguishes from sibling scratchpad tools (open, read, write, run, submit) by specifying a different operation.

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?

Usage is implied for listing one's own scratchpads, but no explicit guidance on when to use this tool versus alternatives (e.g., scratchpad_open, scratchpad_read) or when not to use it. No exclusions or prerequisites 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?

Discloses dual behavior (open vs create) based on pad_id. Without annotations, description partially covers mutation (creation) but omits side effects like session handling or locking.

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, front-loaded with verb and resource, no unnecessary words. Efficient and clear.

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

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

With output schema present but not detailed, description omits return value semantics. Minimal coverage for a dual-purpose tool with 3 parameters.

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?

Only pad_id is explained; title and session remain undefined. Schema coverage is 0%, so description fails to compensate fully.

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

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

Description clearly states action (open/create) and resource (pad), specifying two modes based on pad_id emptiness. Distinguishes from siblings 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?

No guidance on when to use this tool vs siblings. Context like prerequisites or when not to use is missing, leaving agent to infer from 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?

No annotations exist, so the description must disclose behavior. It only states 'read' but omits details like idempotency, authentication needs (inferred from session param), or error handling when file not found.

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

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

The description is a single efficient sentence, front-loaded with the verb. No wasted words, but could benefit from slight expansion.

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 complexity (3 params, 2 required) and no annotations, the description lacks context about what 'YOUR pad' means, prerequisites, or when the manifest is read. Output schema presence mitigates some return value ambiguity but not enough.

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

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

With 0% schema description coverage, the description should clarify parameters. It mentions path condition but does not explain pad_id or session, leaving their purpose unclear beyond names.

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) and resource (file from pad or manifest) and distinguishes from siblings like scratchpad_write and 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 versus alternatives like scratchpad_list or scratchpad_open. The description implies reading files but lacks contextual 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 address behavior. It mentions network disabled (no net) and resource limits (rlimits), and that the entrypoint must set `result`. However, it does not cover failure modes, output format, or other side effects beyond these constraints.

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

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

Two sentences with no filler. Every word adds value: the tool action, the exact sandbox environment, the constraint on entrypoint. Perfectly 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?

While the description covers the core action and constraints, it lacks details on the 'pad' concept, session usage, payload format, and relationship to the sibling sandbox_exec. An output schema exists but is not referenced.

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%, meaning the description adds no parameter explanations. The param names (pad_id, session, entrypoint, cpu_seconds, payload_json) are somewhat intuitive but lack explicit context. Agent would need to infer semantics from the tool name and description.

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

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

The description clearly states the tool runs a pad in a sandbox with restrictions (no net, rlimits). It specifies the entrypoint must set `result`. It distinguishes from siblings like sandbox_exec by emphasizing the exact jail, but could be more explicit about the difference.

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 running code in a restricted sandbox, but does not explicitly state when to use this tool vs alternatives like sandbox_exec. No when-not-to-use guidance is provided.

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

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

With no annotations provided, the description carries full burden. It discloses the 'Never auto-merges' behavior, which is useful, but omits other behavioral traits such as required authentication, potential side effects, or success/failure outcomes.

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, consisting of two sentences that succinctly convey the purpose and a key behavioral note. It is front-loaded and avoids 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?

Given 0% schema description coverage and 4 parameters, the description is incomplete. It provides no explanation for required parameters (pad_id, session, summary) and does not mention the output despite an output schema existing. Differentiation from sibling tools is minimal.

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

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

The description adds meaning only for the 'kind' parameter by listing allowed values. All other parameters (pad_id, session, summary) are left unexplained, despite 0% schema description coverage. The description fails to clarify what these parameters represent.

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

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

The description clearly states the tool's action: 'Submit YOUR pad to the gated contribution journal for sovereign review.' It distinguishes from sibling scratchpad tools (e.g., scratchpad_list, scratchpad_write) by specifying submission to a journal rather than local operations.

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 submitting pads to a review journal and notes that it never auto-merges, suggesting a manual review process. However, it lacks explicit guidance on when to use this tool versus alternatives like other submission tools 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?

With no annotations provided, the description bears full responsibility for disclosing behavioral traits. It states the tool writes content but does not specify whether it overwrites or appends, what permissions are required, or any side effects. Critical details for a write operation 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 with no unnecessary words, achieving high conciseness. However, it lacks structural elements like bullet points or sections that could improve readability for complex parameters.

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 four required parameters with no schema descriptions, an output schema, and numerous sibling tools, the single-sentence description is severely incomplete. It fails to explain parameter usage, return values, or relationships to other scratchpad tools, leaving the agent without essential context for correct invocation.

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

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

Schema description coverage is 0%, so the description must add meaning to the parameters. It does not; it only mentions 'content' implicitly via 'agent-authored content.' The roles of path, pad_id, and session are entirely unexplained, leaving the agent to infer from parameter names alone.

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

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

The description clearly states the tool writes content into the agent's pad and includes a specific caveat ('no server path load') that distinguishes it from other scratchpad operations. However, it doesn't explicitly differentiate from scratchpad_submit or scratchpad_run, leaving minor ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives like scratchpad_open, scratchpad_run, or scratchpad_submit. The parenthetical 'no server path load' hints at one condition but lacks explicit when-to-use or when-not-to-use instructions.

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, and the description does not disclose behavioral traits such as read-only vs destructive, required permissions, or side effects. The term 'memory-mapped' is 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, making it concise, but it sacrifices necessary detail, resulting in under-specification.

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 is too minimal to understand the tool's behavior or how to use its parameters effectively, 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%, and the description adds no information about parameters (depth, address, session) beyond what the schema titles imply.

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 'memory-mapped local subgraph around an address' indicates a specific action and resource, but the term 'FEEL' is vague and lacks detail to fully clarify 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?

No guidance on when to use this tool versus alternatives like sense_scent or other sibling tools; missing context for appropriate invocation.

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 fails to mention whether the tool is a read operation, destructive, or requires specific permissions. The one-line description offers no behavioral context beyond the data it claims to return.

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 sentence), but it is under-specified rather than concise. It omits essential information, so brevity is detrimental rather than 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?

With no annotations, no parameter descriptions, and an output schema not detailed here, the description is grossly incomplete. The agent cannot understand what the tool returns or how to use it properly given the schema and 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%, and the tool description adds no explanation for the two parameters (address and session). The agent receives no help understanding what values these parameters accept or how they affect the tool's behavior.

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

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

The description 'resource-imbalance gradients at an address' suggests the tool returns some data, but lacks an explicit verb like 'sense' or 'detect'. It vaguely indicates what the tool operates on but doesn't clearly state the action, making it less clear than a specific verb+resource formulation.

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 sense_feel or sense_sound. There are no explicit context or exclusions, leaving the agent without criteria for selection.

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

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

No annotations provided. Description mentions 'immutable' implying read-only, but doesn't disclose other behavioral traits like blocking, rate limits, or whether it returns a stream vs single result. Insufficient for agent decision-making.

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?

Overly terse; a single vague sentence that doesn't earn its place as it lacks actionable information. Not appropriately sized for a 3-parameter 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?

Given the tool has 3 parameters with no schema descriptions, no annotations, and an output schema (unknown content), the description is completely inadequate. It does not specify what the tool returns or how to use the parameters.

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 fails to explain any of the 3 parameters (kind, limit, session). No added 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?

Description states it's an 'immutable event-log stream' but lacks a verb specifying the action (e.g., list, read, sense). It restates the tool name 'SOUND' without clarifying what operation it performs.

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 siblings like sense_feel or sense_scent. No context about typical use cases 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 carry full behavioral disclosure. It only says '(re)price', implying mutation, but does not state whether the operation is reversible, if it triggers notifications, or any permission requirements beyond 'Producer I+'. No side effects or idempotency info.

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 fluff, making it concise. However, it lacks structure such as bullet points or separate sections for clearer readability. It is acceptable but could be better organized.

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?

Though an output schema exists (relieving the need to explain return values), the description still lacks critical context. It does not cover parameter formats, prerequisites, or error scenarios. For a tool with 3 required parameters and no schema descriptions, the description is incomplete for safe and correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no parameter details. The description does not explain what 'session' is, the format of 'listing_id', or constraints on 'price' (e.g., minimum, maximum, currency). The agent receives no additional meaning beyond the parameter names.

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 verb '(re)price' and the resource 'one of your own listings', clearly indicating the action and scope. It distinguishes from sibling tools like 'list_listings' which list but do not modify prices. The reference to 'Producer I+' adds context but is jargon; still, the core purpose is clear.

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

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

No explicit guidance on when to use the tool or when not to. The description only implies it's for the user's own listings, but does not explain prerequisites, alternatives, or conditions. For instance, it doesn't mention that the listing must exist or not be in a locked state.

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 the burden. It discloses the no-auto-pay behavior but lacks details on post-submission actions, prerequisites, or error states.

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 single sentence. Front-loaded with key info, but lacks any structural formatting like bullet points or sections.

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

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

For a tool with 4 parameters, no parameter descriptions, and no annotations, the description is too minimal. It omits return value context (though output schema exists) and prerequisite details.

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

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

Schema description coverage is 0%, and the description provides no explanation of parameters (session, bounty_id, summary, evidence). No added meaning beyond the schema fields.

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

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

The description clearly states the action (submit delivery), the target (sovereign review), and a key constraint (no auto-pay). It distinguishes from siblings like claim_bounty and 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 explicit guidance on when to use vs alternatives. The 'no auto-pay' hint is implicit, but no context on scenarios 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 exist, so the description must fully disclose behavior. It hints at a process but does not explain side effects, required permissions, failure modes, or the nature of the 'atomic swap'. The agent cannot predict what happens upon invocation.

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) but is cryptic and uses jargon without explanation. It is under-specified rather than genuinely concise; every word is present but not 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 has 6 parameters (5 required), no parameter descriptions, no annotations, and a complex process implied, the description is severely incomplete. It fails to provide essential context about inputs, outputs, side effects, or usage 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?

The input schema has 0% description coverage, and the description does not explain any of the 6 parameters (e.g., domain, deposit, session, occupant, source_name, license_name). The agent has no semantic clues for constructing valid arguments.

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

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

The description states it's a challenge for a keel slot and outlines a process (compliance scan, eval referee, atomic swap). However, the meaning of 'keel slot', 'compliance scan', and 'atomic swap' are not explained, making the purpose vague and unclear for an agent without domain knowledge.

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 the many sibling tools. The description does not mention prerequisites, conditions, or alternatives, leaving the agent without decision 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 exist, and the description offers no behavioral details (e.g., side effects, permissions, rate limits). The tool's behavior is entirely opaque.

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 but sacrifices clarity for brevity. It is not concise in a helpful sense; it is under-specified.

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, no annotations, and an output schema that is not referenced, the description is grossly incomplete and inadequate for selecting or invoking the tool.

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

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

With 0% schema description coverage, the description must explain parameters but does not. It adds no meaning to 'body', 'session', 'problem_id', or 'sources_json'.

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 uses jargon like 'flip problem, event, Mint FIRE' and 'Inbox mark line,' failing to state a clear verb and resource. It does not help 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 is provided on when to use this tool versus alternatives, nor any prerequisites or 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 provided, the description must disclose behavioral traits. It only says 'run one request through', but does not indicate whether the operation is destructive, idempotent, or requires specific permissions. The agent lacks critical safety information.

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 sacrifices clarity and completeness. It could be more informative without adding length, such as explaining what 'STABLE socket' or 'keel' means.

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 four required parameters and no schema descriptions, the description is severely incomplete. It omits explanation of parameters, output (despite an output schema existing), and any side effects, making it insufficient for effective use.

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

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

The description adds no information about the four required parameters (session, domain, task, text). Schema coverage is 0%, so the agent must rely solely on parameter names, which is insufficient for correct invocation.

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 runs a request through a stable socket, but the term 'STABLE socket' and 'keel' are domain-specific jargon, making the purpose unclear for an agent without context. It distinguishes itself from siblings like a2a_send by mentioning a specific socket type, but ambiguity remains.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, typical use cases, or when not to use it, leaving the agent without decision-making 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, the description fully bears the burden of behavioral disclosure. It does not specify whether this tool is read-only, if it mutates state, or any permissions/rate limits. The phrase 'every transfer attempt' implies a read operation, but this is not explicit.

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

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

The description is a single cryptic sentence. It is under-specified rather than concise, lacking essential details for an agent to understand 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 fails to give a high-level overview of what the tool returns or how 'bucket' relates to the output. The context is incomplete for a simple tool with one parameter.

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 for the undocumented 'session' parameter. However, the description only mentions 'this session' without explaining the parameter's meaning, format, or values. No added value over 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 'The bucket: every transfer attempt this session, allowed or blocked' is vague and uses jargon ('bucket'). It hints at listing transfer attempts but does not clearly state the tool's purpose or distinguish it from siblings like wallet_transfer.

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. Sibling tools exist (e.g., wallet_transfer) but no contrasting information is given.

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