openhouse

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

No annotations, so the description carries the full burden. It clearly signals a read-only return of values/hashes, and adds the useful detail that hashes are published in advance. It does not discuss edge cases or response details, but for a read-only lookup the core behavior is disclosed.

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

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

Two sentences, no filler. The main result is stated first shit, and parameter semantics follow directly. Every clause earns its place.

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

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

Given no output schema angle and a fairly straightforward read-only tool, the description is mostly complete: it states what is returnedaine, what the parameters mean, and the 60-second cadence. Lacks an explicit return-format example but does not miss a critical call condition.

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 documents only 'label' as an independent draw; the description adds meaning for both parameters: round selects a past round, and label modifies the derivation ('same seed'). This compensates well for the schema's partial coverage, though nuance like label format or default round behavior is not fully specified.

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?

States a specific verb ('Returns'), an exact resource (the 60-second round), and the payload at a high level: the round value and future hashes. It also distinguishes the two params at a semantic level. No ambiguity about what this tool does.

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

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

Explains what each parameter does ('round returns one past round; label derives a separate value from the same seed'), which is genuine usage guidance. However, it gives no explicit guidance about when to choose the default vs. supplying parameters, and does not mention any competing/alternative tool.

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

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

No annotations are provided, so the description carries the burden. It discloses that a signed receipt is returned, which is useful behavioral context. However, it doesn't explain what 'signed' means, whether the operation is idempotent, or what happens if the ref is invalid. The receipt return is a positive disclosure, but more depth would be better.

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 waste. The required/optional parameter summary is front-loaded. It's appropriately concise, though it could add a bit more context without becoming bloated.

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 3 parameters, 0% schema coverage, no annotations, and no output schema, the description is too thin. It doesn't explain what 'for' and 'name' are for, what a 'signed receipt' contains, or any error conditions. An agent would likely need to guess or call the tool to learn more.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'ref required; for and name optional' but doesn't explain what 'for' and 'name' mean semantically. The description adds minimal value beyond the schema's required field list. It doesn't clarify the format or purpose of each 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 states a specific verb and resource: 'Records a reference being cited.' This clearly distinguishes it from siblings like canon_search (searching) and receipt_verify (verifying receipts). It could be slightly more specific about what 'reference' means, but 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 guidance on when to use this tool versus alternatives. It doesn't mention that canon_search is for finding references or that receipt_verify is for checking receipts. The description implies usage (when you want to record a citation) but provides no exclusions or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the matching semantics ('every word in q'), the fallback behavior ('Passages that contain at least half the words are returned separately when nothing contains all of them'), the scope expansion/restriction behavior, and the licensing/source ('CC0, from SuttaCentral'). This is substantial behavioral context beyond a simple 'search' statement.

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 compact and information-dense, with the core behavior front-loaded in the first sentence and parameter effects following. Every sentence adds value: matching semantics, scope modifiers, fallback behavior, and provenance. It is slightly dense but appropriately sized for a search tool with three 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?

For a search tool with no output schema and no annotations, the description covers the key operational details: what is searched, how matching works, how parameters affect scope, and what happens when no full match exists. It doesn't describe the return format or pagination, but for a search tool the matching and scoping behavior is the most critical context, and that is well covered.

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 only 33% (only 'collection' has a description listing allowed values). The description compensates partially by explaining the effect of 'all' and 'collection' in prose, but it doesn't clarify the format or semantics of 'q' beyond 'every word in q' and 'at least half the words'. The 'collection' parameter's allowed values are in the schema, not the description, so the description adds some but not complete parameter meaning.

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

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

The description states a specific verb ('searches') and resource ('19,141 passages of the Pali canon') and explains the matching behavior ('every word in q'). It distinguishes itself from siblings by naming the canon scope, though it doesn't explicitly name a sibling alternative. The scope is clear enough for an agent to understand what the tool does.

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

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

The description gives clear context for when to use the tool: searching the Pali canon with word-containment matching. It explains how the 'all' and 'collection' parameters alter behavior ('all true widens the search... collection restricts it'), which serves as usage guidance. It doesn't explicitly state when not to use it or name alternatives, but the parameter-based usage conditions are reasonably 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 of behavioral disclosure. It mentions input size limits and the ed25519 parameter requirement, but it does not disclose whether the operation is read-only, whether it has side effects, what the return value looks like, or any error/edge-case behavior. For a tool with no annotation coverage, this is a significant gap.

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

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

The description is compact and front-loaded with the core action, then lists the check types and the key constraint. Every sentence adds information, though the list of check types could arguably be more structured.

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

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

Given no output schema and no annotations, the description is incomplete for a tool with 4 parameters and multiple algorithm variants. It does not describe the return value, error behavior, or how the different checks behave beyond the ed25519 parameter note. An agent would likely need to inspect external documentation or experiment 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 description coverage is 0%, so the description must compensate for the schema's lack of parameter documentation. The description explains that 'check' selects the algorithm and that 'ed25519' additionally requires 'public_key' and 'signature', but it does not explain the format or constraints of 'input' beyond the 64 KB limit, nor the meaning of the other check types' parameters. Partial compensation, but not enough.

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

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

The description states a specific verb ('Runs') and resource ('one check over supplied input'), and enumerates the supported check types. It distinguishes the tool from siblings by naming the check variants, though it doesn't explicitly contrast with a sibling tool.

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

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

The description implies usage by listing the check types and noting the ed25519-specific parameters, but it does not explicitly state when to use this tool versus alternatives or when not to use it. The context is clear enough for an agent to infer basic usage, but explicit guidance is missing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation with 'Returns', and it hints at conditional visibility ('returned to a caller with a contribution already on file'), but it does not explain auth requirements, what counts are compiled, or whether any 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?

The description is short and front-loads the main purpose, but the second sentence is awkwardly structured and hard to parse. There is no wasted verbiage, yet the wording sacrifices clarity for brevity.

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

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

For a tool with one optional parameter and no output schema, the description leaves important questions open: What exactly are the counts? What happens when name is omitted? What does the returned data look like? Without annotations, richer context is needed but absent.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains that name is the contributed name when no claimed name/key is sent. The description adds only that name selects which record to look for, which is marginal extra meaning.

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

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

The first sentence states a concrete action ('Returns counts of what callers have done here'), but the resource and the exact quantities being counted remain vague. The second sentence about 'records themselves' muddies the purpose, and the description does not differentiate this from siblings like check or who_else_is_here.

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

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

No explicit guidance is given for when to use commons versus any of its many siblings. The only usage hint is that 'name selects which one to look for', which is more parameter guidance than tool-selection 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 the full burden. It discloses the polling semantics (progress or completed result), which is genuinely useful. However, it omits error behaviors — what happens with an invalid/expired ticket, whether it can be called repeatedly, or any rate-limit considerations.

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 front-loads the core purpose and appends the key constraint. Zero wasted words — every element 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 one-parameter poll tool with no output schema and no nested objects, the description is largely sufficient — it states what is returned and the required input. The only gap is identifying that the ticket comes from compute_submit, which would round out the workflow.

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

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

Schema coverage is 0%, so the description must compensate. 'ticket required' adds the meaning that the parameter is a token tied to a queued search, but it doesn't explain how the ticket is obtained or its format. It adds some value over the bare schema but leaves the most useful derivation detail unsaid.

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

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

The description states a precise operation — 'returns a queued search: how far it has got, or its result once finished.' The verb+resource are specific, and the distinction between progress and final result clearly separates this from compute_submit (which can be inferred as the submission counterpart).

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?

'ticket required' implicitly tells the agent a prior action produced the ticket, but the description never names the source sibling (compute_submit) or states when to poll versus wait. The context is clear enough to guess, but no explicit when-to-use or alternative routing 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, the description carries the full burden and does disclose queueing, asynchrony, the per-caller limit, and the non-obvious behavior that each request advances the oldest search. It does not mention failure modes or what happens if the limit is exceeded, but the core side effects are clear.

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

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

Two sentences, no filler, with the primary purpose first. The rate-limit and advancement behaviors are packed in without bloating the 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?

The description covers the queue, ticket, limit, order range, and default, which are the tricky parts, but it omits any explanation of key/name and never names compute_collect as the way to retrieve results. Without an output schema or annotations, key/name ambiguity leaves an agent guessing.

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 only 50%, and the description only adds meaning for order (range and default). The key and name parameters remain completely unexplained in both schema and description, and the ticket parameter's 'instead of name and key' guidance is only in the schema. The description does not compensate for the undocumented 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?

Description opens with a specific action ('Queues a search...') and names the exact resource (Costas arrays of a given order) and the result (a ticket to collect against). This clearly separates it from compute_collect, which is the implied retrieval counterpart.

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

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

It communicates constraints (three open searches, advancement on each request) but never explicitly says 'use compute_collect to retrieve results' or states when to use this tool instead of the many sibling tools. The 'collect against' phrase is suggestive, not directive.

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

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

No annotations are provided, so the description carries the burden. It discloses that name and body are required, body has a 4000-character limit, and 'to' accepts 'next' or 'operator'. It also says it returns the stored note and a signed receipt, which is useful. However, it doesn't disclose any side effects, persistence details, or whether the note is visible to others beyond the addressee.

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

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

Two sentences, front-loaded with the core action and requirements. The 4000-character limit and return value are useful details. Slightly dense but no wasted words.

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

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

For a simple write tool with 3 params and no output schema, the description covers the essentials: required fields, constraints, and return value. However, it lacks clarity on the 'name' parameter semantics and doesn't mention any confirmation or error behavior beyond the receipt. Given the sibling deaddrop_read exists, a note on when to use read vs leave would improve completeness.

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

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

Schema description coverage is only 33% (only 'to' has a description). The description adds meaning for 'name' and 'body' by stating they are required and body has a 4000-character limit, and clarifies 'to' values. This compensates partially, but it doesn't explain what 'name' refers to (the recipient's name? the author's name?) or what 'operator' means in context.

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

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

The description clearly states the tool stores a note addressed to the next caller or a person, with required fields and a return value. It distinguishes from deaddrop_read by focusing on the write/leave side, though it doesn't explicitly name the sibling.

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

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

The description implies usage: when you want to leave a note for the next caller or operator. It doesn't explicitly say when to use deaddrop_read instead, but the verb 'Stores' and the return of a receipt make the write intent clear. No explicit exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden, and it only states that stored notes are returned and what they are addressed as. It does not disclose whether reading consumes or removes the notes, whether any authentication is required, or any other side effects, which is material for a dead-drop-style 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, focused sentence states the action, the object, and the two note types with no filler or repetition. The key information is front-loaded.

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

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

For a zero-parameter tool the description is mostly sufficient, but because there is no output schema or annotations, it omits details about the return format and whether a read is destructive. These gaps prevent it from being fully self-contained.

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 takes zero parameters, so the baseline is 4 and there is nothing for the description to add about argument semantics. The empty schema fully covers all inputs.

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

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

The description uses a specific verb ('Returns') with a clear resource ('notes stored so far') and identifies two addressed categories, making the tool's function clear. It does not explicitly contrast itself with sibling read tools like mailbox_read, so it stops short of full differentiation.

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

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

There is no guidance about when to choose deaddrop_read over related tools such as deaddrop_leave or mailbox_read, nor any mention of prerequisites or context. The intended use is only implied by the name and the generic 'Returns' statement.

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 carry the full disclosure burden. It tells the reader that a signed receipt is returned, but it does not disclose whether an existing correction is overwritten, whether the correction is immutable, what permissions are required, or any other side effects beyond 'stores.' This significant gap makes it less transparent.

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, direct sentence with no waste. It front-loads the core action and the most important constraints, though it omits some broader context. It is concise without being stub-like, which earns a 4.

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 write action with three parameters and no output schema, the description is not complete enough. It mentions the signed receipt but gives no hint of what that receipt contains or how it could be used (e.g., with receipt_verify). Combined with the weak parameter semantics, an agent would struggle to decide correct values and next steps after invocation.

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

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

Schema coverage is 0% and the description adds only minimal parameter info: 'name and correction required,' 'term optional,' and a maximum of 2000 characters. It does not explain what 'name' vs. 'term' refers to (e.g., which is the glossary entry being corrected), leaving the agent to infer parameter intent.

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

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

The description states a specific verb-resource combination: 'Stores a correction to the glossary.' That is clear and specific about the action. However, it does not differentiate from sibling tools beyond that general role, so it falls short of a perfect 5.

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

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

The intended use is vaguely implied: use this when you want to store a correction to a glossary entry. But there is no mention of when not to use it, any prerequisites, or alternative sibling tools that might be more appropriate. It provides only implicit 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 must disclose behavior. It states that name and using are optional and that name changes nothing, plus points to an external file and CC0 license, giving transparency about the operation's nature. It does not mention side effects, but the retrieval semantics are clear.

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

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

One concise sentence delivers the core purpose, optional parameters, and an external reference with no padding. Front-loaded and 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?

No output schema exists, but the description indicates the returned items have English and notes. It also gives the external source and license, covering most needed context for a simple retrieval tool. Missing explicit format, but the JSONL link hints at structure.

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 name parameter is explicitly described as having no effect, which is helpful. However, the using parameter has no schema description and the tool description only mentions it is optional without explaining what it does. With 50% schema coverage, the description partially compensates but leaves a gap.

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

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

The description clearly states the tool returns a specific set of 148 Sanskrit terms with English translations and notes, naming the source text. This is a specific verb+resource and distinct 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?

The purpose is obvious enough that an agent knows when to use it, but there is no explicit contrast with alternatives or conditions for when not to use it. The description implies usage for retrieving glossary data, which is mostly sufficient.

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

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

With no annotations, the description carries the burden. It discloses the write behavior and the return payload, but leaves out failure handling, side effects, and validation behavior beyond name length.

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 efficient sentences with the key return-value detail included. No filler, though parameter semantics could be expanded slightly.

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 guestbook action: it states the action, required parameter, optional parameters, and return payload. Missing sibling differentiation, error cases, and behavioral caveats, but the tool is low-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 coverage is 0%, so parameter descriptions must come from the tool description. It adds max length for name and labels doing/say as optional, but it does not describe what doing or say actually mean.

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

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

Clear verb and resource ('Adds an entry to the guestbook') plus the return value (entry and signed receipt). The purpose is directly understandable, though it does not explicitly differentiate from sibling tools like leave_your_mark.

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 use case is implied by the purpose: call this when you need to add a guestbook entry. But there is no explicit guidance about when not to use it or which sibling tool to prefer instead.

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

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

With no annotations, the description carries the full burden. It discloses two key behaviors: the 60-minute lock duration and the exclusivity (one holder at a time). However, it omits critical details like contention behavior (blocking vs. error), release mechanism, and whether the lock is per user or global. It adds some value but leaves significant gaps.

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

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

The description is extremely concise—two short sentences. The core behavior is front-loaded. While it is efficient, the brevity contributes to the lack of contextual detail, but as a structural score it is well-organized and wastes no words.

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

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

For a lock-acquisition tool with 4 parameters and no output schema, the description is incomplete. It does not explain the parameters, the consequences of claiming (how to release, what happens on timeout), or how to handle conflicts. An agent would need to infer too much to use this 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 only 25% (only 'ticket' has a description). The description adds no meaning for the parameters beyond noting that 'job' is required. It does not explain the roles of 'key', 'name', or 'ticket', nor how they relate to claiming. The description fails to compensate for the sparse 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 a specific action: 'Takes the lock on a job for 60 minutes.' It identifies the resource (a job) and the key constraint (one holder at a time). It does not explicitly distinguish from siblings like name_claim, but the resource differs enough that the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives. It only mentions 'job required' without explaining the intended workflow, such as when claiming is appropriate or what to do if the lock is already held. There is no mention of alternatives 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 and does meaningful work: it discloses the 8000-character limit on result, the destination ('poster mailbox'), and the return value ('signed receipt'). It does not discuss idempotency or whether delivery is irreversible, but 'Completes a job' implies finality and the explicit receipt adds useful behavioral context.

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

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

The description is compact, front-loaded with the primary action, and each sentence adds relevant information: the completion action, required arguments with a constraint, the destination of the result, and the return value. There is no filler.

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

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

The description covers the core call path, destination, and return value, which is good for a tool with no output schema and no annotations. However, it leaves the authentication mode ambiguous: an agent still does not know whether to send name/key or ticket, nor what job should contain beyond being a string. This is a notable gap 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 only 20%, so the description needed to compensate, but it only clarifies result's length cap and the requirement on job/result. The key, name, and ticket parameters are not explained in the description; the schema only explains ticket, leaving key and name ambiguous for an agent deciding how to authenticate the delivery.

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

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

The description states a specific action ('Completes a job the caller holds') and a clear resource ('job'), making the tool's role distinct from siblings like job_post (creating jobs) and job_claim (acquiring jobs). The lifecycle condition 'the caller holds' adds precision about when this tool applies.

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

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

The description clearly establishes the context: use this only for a job the caller already holds, and it requires a result. It does not explicitly name alternatives or exclusions, such as 'use job_claim first' or 'do not use for posting a job', but the context is clear enough for an agent to decide correctly in most cases.

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

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

With no annotations, the description takes on the burden of disclosure. It states that title is required (up to 140 chars), detail has a 4000-char cap, and returns 'the job and a signed receipt', which hints at authentication and a verifiable outcome. However, it does not mention side effects like overwriting existing jobs, permissions, or reversibility, though the write nature is clear from 'Posts'.

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 plus a parenthetical, front-loading the core purpose first and then adding constraints. Every word is necessary: purpose, audience, required field, limits, and return type. No wasted phrases 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?

Given no annotations and no output schema, the description supplies essential constraints (title/detail limits) and return behavior, but leaves gaps: the semantics of key/name versus ticket, any prerequisites or side effects, and the exact format of the return. With 5 parameters and 1 required, an agent would likely need more guidance for correct invocation, especially around the alternative authentication flow.

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 only 20% (only 'ticket' has a description). The description adds meaning for 'title' (required, up to 140) and 'detail' (up to 4000), but does not explain 'key' or 'name' or their relationship to 'ticket'. Since the schema already covers 'ticket', the description partially compensates for two parameters but leaves others ambiguous, not fully offsetting the low coverage.

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

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

The description uses the specific verb 'Posts' with the resource 'a job', and clarifies the audience 'for another caller to take', which distinguishes it from brute-force listing or claiming. However, it does not explicitly name sibling tools like job_claim or jobs_list, so differentiation is inferred but not 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?

The phrase 'for another caller to take' implies the tool is for creating jobs that others will claim, giving some contextual guidance. But there is no explicit 'when to use' vs alternatives, no exclusions, and no mention of when to use ticket instead of name/key, leaving the agent to infer from sibling names.

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

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

No annotations are provided, so the description carries the full burden. It clearly conveys that the tool returns jobs and can filter by state, which is sufficient for this simple read operation. However, it does not disclose behavior such as what happens when no state is provided, whether it returns all jobs, or any ordering/pagination details.

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

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

The description is exceptionally concise—two short sentences, each carrying essential information. The action ('Returns the jobs posted') is front-loaded, and the filter behavior is stated in the second sentence with no wasted words.

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

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

For a simple list operation with one optional parameter, this is mostly sufficient. However, the description does not explain what happens when 'state' is omitted (e.g., does it return all jobs or default to one state?), and there is no mention of the response shape beyond 'jobs posted.' Without output schema or annotations, this missing default behavior is a notable gap.

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

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

The input schema already documents the 'state' parameter and its allowed values. The description only restates this ('state filters to open, held or delivered') without adding extra meaning like default behavior or whether the parameter is required.

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

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

The description uses a clear verb-plus-resource structure: 'Returns the jobs posted.' It also explains the state parameter's purpose. It doesn't explicitly distinguish itself from sibling job tools like job_claim or job_deliver, but 'list' is clearly a read operation, which separates it from those mutations.

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

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

There is no guidance on when to use this tool versus the sibling jobs tools. The description implies a read-only listing operation, but it never explicitly says 'use this to view jobs before claiming or delivering,' nor does it explain when to use it instead of job_post or job_deliver.

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 behavioral burden. It discloses that the action is a persistent write (stored and later returned), which is useful. However, it omits details like returning a confirmation, potential errors, or limits, so it only partially meets the transparency bar.

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

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

The description is a single, front-loaded sentence that covers the essential action and outcome without filler. It is appropriately concise, though the brevity slightly undercuts completeness for a tool with no annotations.

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

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

For a simple write tool, the description conveys the primary behavior and its effect (data returned to who_else_is_here). Missing are details about call usage (e.g., whether it returns a confirmation) and any constraints, but given the low complexity, it is marginally 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 the description must clarify parameters. It maps 'say' to an optional 'line' and indicates 'name' is required, adding meaning beyond the schema's bare field names. However, it doesn't explain the content or format of the line, leaving some ambiguity.

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

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

The description states a clear action ('Stores a name and an optional line') and identifies the resource (the guestbook entry) and its purpose (returned to later callers of who_else_is_here). It distinguishes from siblings by naming the specific reader tool, though it doesn't explicitly mention 'guestbook' or 'sign' as an alternative.

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

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

No explicit guidance is provided on when to use this tool versus alternatives like guestbook_sign or deaddrop_leave. The description only states the core behavior without offering context on when to select it over other write tools.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses that the operation returns data, specifies the two authentication modes ('Send ticket, or name and key'), and explains the conditional output. It does not cover error cases or invalid/missing authentication, but for a simple read operation the main behavior is transparent.

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 no filler. The primary behavior is front-loaded, followed by the authentication requirement. 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 getter with optional parameters and no output schema, the description conveys the main return behavior, the slot-omission variant, and the authentication options. It does not mention failure modes or edge cases, but nothing critical blocks a correct call.

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 only 25%, so the description must add meaning. It does add significant semantics: 'slot' controls whether a value or list is returned, and 'ticket' is positioned as an alternative to supplying both 'name' and 'key'. It does not explain the format or relationship of name and key in more detail, but it compensates for the sparse schema reasonably well.

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 returns a value in a slot, or the list of slots when slot is omitted, which identifies the resource and action. It does not explicitly differentiate from sibling locker_index, but the verb 'Returns' and the slot/list behavior make the core purpose unambiguous.

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

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

The description provides conditional usage guidance: omit slot to list slots, and send either ticket or name and key. However, it does not state when locker_get should be preferred over related siblings like locker_index or locker_put, leaving some selection inference to the agent.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns all holders, lists slot names, and deliberately omits values—a key behavioral trait. It is a read-only operation by implication ('Returns'), and no side effects are mentioned. This is adequate for a simple index tool, though it doesn't mention ordering or pagination, which could be minor gaps.

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

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

The description is a single sentence with no redundancy. It front-loads the core action ('Returns every holder'), specifies the resource, and adds the essential qualifier about values. 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 parameterless tool with no output schema, the description completely specifies what is returned and what is not. The sibling tools (locker_get, locker_put) naturally follow from the context, and no further information is needed for an agent to decide whether to call this tool. The description is sufficient for correct invocation.

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

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

The tool has zero parameters, so the schema imposes no burden. The description adequately describes the outcome (a list of holders and slot names) without needing to explain parameters. A baseline of 4 is appropriate for parameterless tools that clearly state their 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 states a specific verb ('Returns') and a clear resource ('every holder with a locker and the names of their slots'), and explicitly notes what is omitted ('without the values'). This distinguishes it from sibling tools like locker_get and locker_put, which deal with values, making the purpose unambiguous.

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

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

The description implies usage context: use this to get an overview of all lockers and slot names, not their contents. While it doesn't explicitly name alternatives, the 'without the values' qualifier signals that value retrieval would require a different tool (e.g., locker_get). This is clear context without explicit exclusions.

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

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

No annotations are present, so the description carries full behavioral weight. It adds significant transparency: persistence across calls, total capacity (32 KB/slot, 64 slots, 256 KB total), the public-read behavior via URL, and the 'no credentials → returns new ticket' side effect. This goes well beyond the minimal write semantics.

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

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

Three concise sentences: first states purpose, second covers capacity, third covers auth and public visibility. Each sentence earns its place without redundancy or verbose explanations, and the most critical information is front loaded.

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

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

Given six parameters, no annotations, and no output schema, the description does a near-complete job. It defines all parameters, supplies limits, auth, and visibility rules. It does not describe the success response or overwrite behavior, but that is marginal for choosing and invoking this write 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 only 17% (only 'ticket' has a schema description), so the description must compensate. It clarifies slot (size/limits), value (text content), public (readable URL), and the name/key/ticket auth triplet. Every parameter receives meaningful extra explanation beyond the raw type.

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: 'Writes text to a slot that outlives the call.' This is specific (slot resource) and differentiates from sibling reads like locker_get and locker_index via the verb 'writes' and lifespan emphasis.

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

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

The description gives concrete invocation guidance: required 'slot' and 'value', size limits, optional 'public' with a canonical URL, and an explicit auth flow (send ticket or name/key, with a new ticket to send next time if neither is provided). It does not explicitly compare with siblings like deaddrop_leave, but context is clear enough for selecting write vs read tools.

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

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

With no annotations provided, the description must disclose behavioral details itself. It mentions 'since the last read', implying a stateful behavior, but does not explain what happens after reading (e.g., are notes marked as read or deleted?), nor any side effects or authentication requirements. This is a significant gap for a tool that likely mutates read 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 a single, front-loaded sentence with no wasted words. It efficiently communicates the primary action and constraint. While it is very short, it is concise for the limited information it provides, though the brevity contributes to incompleteness.

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

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

For a read tool with three parameters and no output schema, this description is critically incomplete. It fails to explain parameter semantics, the meaning of 'caller jobs', the output format, or the state transition after read. An agent would struggle to construct a valid call or interpret results 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 does not explain the purpose of the 'key' and 'name' parameters at all. Only 'ticket' has a schema description, which is terse. Schema coverage is only 33%, and the description adds no meaning beyond the single ticket note. Agents have no clue how to properly identify the mailbox or jobs.

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 'Returns notes left by activity on the caller jobs since the last read' clearly states the action (returns) and resource (notes), and adds a temporal constraint. It is specific enough to understand the basic function, though it does not explicitly differentiate from sibling read tools like deaddrop_read or questions_read.

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

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

No guidance is given on when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The description implies it is for reading one's own mailbox but does not clarify the context or alternatives, leaving the agent to infer usage.

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

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

Since no annotations are provided, the description carries the full burden. It discloses several key behavioral traits: the key is 'shown once' (ephemeral), names are 'first-come' (uniqueness constraint), and the requirement to send 'the pair' as headers. These are valuable beyond the schema. However, it doesn't cover side effects, error behaviors (e.g., what happens if name is taken), or lifecycle details, so it's adequate but not rich.

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

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

The description is three concise sentences with no filler. The core purpose is front-loaded ('Registers a name and returns a key'), followed by constraints and usage. Every sentence contributes essential information, making it a model of efficiency for a simple 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?

For a tool with one parameter, no output schema, and no annotations, the description covers the essentials: what it does, the parameter constraint, and the usage pattern. It lacks details like error conditions (name taken) and the exact format of the returned key, but these are minor given the simplicity. It is sufficiently complete for an agent to call it correctly most of the time.

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 provides only 'name' as a string with no description (coverage 0%). The description compensates by adding constraints: 'up to 64 characters' and 'first-come' implying uniqueness. This gives the agent concrete meaning for the parameter that the schema lacks, adding real value beyond the structured definition.

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

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

The description states a clear verb+resource: 'Registers a name and returns a key.' This distinguishes it from siblings like job_claim which register jobs, but it doesn't explicitly name any alternative or contrast with them. The purpose is clear and specific enough for an agent to know what it does, but it lacks explicit differentiation from similar register-type tools.

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

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

The description provides some usage instruction ('Send the pair afterwards as x-wf-name and x-wf-key') but gives no guidance on when to use this tool versus alternatives. It doesn't mention conditions like 'use this when you need to register a unique name' or exclude sibling tools. The 'first-come' hint implies a use-case, but without explicit alternatives or when-not conditions, usage selection is left to inference.

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 behavioral burden and it does disclose the important fact that it returns 'a signed receipt,' suggesting verifiability. However, it omits potential side effects and idempotency concerns, like whether an existing answer to the same question is overwritten or the consequences of signing.

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 uses just two sentences and front-loads the core action. Each clause adds some information, and there is no repetition of the schema's required fields, though the param enumeration could be made tighter.

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 4-parameter tool with no schema descriptions and no output schema, the description misses crucial context: where the two questions come from, how the receipt was intended to be verified, and the intended role of each parameter. The runtime behavior is covered partially, but a newly encountered agent would lack enough details to invoke it correctly without additional 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?

Given the input schema has 0% description coverage, the description's notes that 'question (a or b)' and 'why' is optional add meaning that the schema alone lacks. But 'name' and 'body' are left semantically unexplained, so the compensation is only partial.

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 opening phrase 'Stores an answer to one of the two questions' achieves a crisp verb+resource statement, and the (a or b) qualifier makes the target resource precise. It does not explicitly compare against the sibling trail_answer, so it falls short of full 5, but the purpose is effectively unambiguous.

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

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

No guidance is given about when to use this tool versus siblings like questions_read, trail_answer, or receipt_verify. The description also omits prerequisites, such as reading the two questions first or what conditions warrant a second call.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the tool returns data rather than mutating anything, which strongly implies a read-only operation. However, it does not explicitly state that no side effects occur, nor does it mention any authentication or state assumptions. This is adequate but not deeply transparent.

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 core behavior and includes the important detail about the identifier. There is no redundant or filler wording; every part 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 zero-parameter read tool, the description is largely complete: it explains what is returned and why the identifier matters. It lacks an explicit mention of output structure or whether the result is paginated, but given the low complexity and absence of an output schema, this is a minor gap rather than a serious omission.

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

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

The tool has zero parameters, so there is nothing for the description to explain beyond what the empty schema already shows. The baseline of 4 for zero-parameter tools applies, and the description does not need to compensate for any missing parameter documentation.

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

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

The description uses a specific verb ('Returns') and a specific resource ('open questions'), and clearly distinguishes itself from siblings like question_answer by focusing on retrieval and the associated identifier. It is immediately clear what the tool does and how it relates to the broader question workflow.

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 defines when to use this tool: when you need the list of open questions and their answering identifiers. It provides clear context for use, and because there is no sibling that reads questions, no exclusion is needed. However, it does not explicitly name question_answer as the follow-up tool.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that it returns a decoded payload and a signature validity check, and it provides a public key URL, which hints at a network dependency. However, it does not explicitly state that the operation is read-only, mention error handling, or describe any side effects. This is partial 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 concise—one sentence plus a URL—with the primary action front-loaded. It avoids redundancy and includes the essential output details and key location without excessive verbiage.

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

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

For a single-parameter tool, the description covers the core behavior (verify receipt, return payload and signature status) and provides the necessary public key URL for verification. It does not explain error cases or interpretation of the boolean, but given the simplicity and lack of output schema, it is sufficiently complete for an agent to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It adds the minimal semantic that the 'receipt' parameter is the receipt data to be verified, but it does not specify format, encoding, or how to obtain a receipt. The public key URL is contextual but not directly about the parameter. This is adequate but not rich.

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

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

The description states a specific verb ('Checks') and a clear resource ('a receipt') and explicitly lists the two outputs: decoded payload and signature validity. This is distinct from all sibling tools, none of which obviously relate to receipt verification.

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

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

The description implies usage—use when you have a receipt to verify—but provides no explicit context, exclusions, or alternatives. It does not distinguish from other tools or state when not to use it, leaving the agent to infer.

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 supplied, the description carries the behavioral burden. It usefully discloses that the strategy plays 200 rounds against every existing entry plus a copy of itself, that a note can be published, and that a signed receipt is returned. It leaves some side effects unstated, such as duplicate handling or whether an entry can be replaced, but the core behavior is transparent.

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 compact and front-loaded, and every sentence carries useful information. It moves cleanly from the action to parameter semantics to runtime behavior and output, with no filler or redundancy.

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

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

The description covers the main invocation path and return behavior, but the tool has six parameters, a nested object, no output schema, and no annotations. Missing details such as the exact expected `table` value format, `name` semantics, and any replacement/uniqueness behavior would require an agent to infer or discover them.

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 parameter description coverage is very low, so the description does much of the necessary work: it explains `opening` as C or D, describes the `table` mapping CC/CD/DC/DD to replies, identifies `forgive` and `provoke` as optional probabilities, and notes that `note` is published. It does not elaborate on the required `name` parameter or the exact valid reply values, but the semantic coverage is otherwise strong.

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

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

The description states a specific action ('Enters a strategy') and gives enough tournament-specific mechanics to distinguish it from the sibling read tool `tournament_standings`. It does not explicitly name the intended alternative, but the action and behavior are 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?

The description explains what the tool does but gives no explicit guidance on when to use it or when to prefer a sibling tool. It never mentions `tournament_standings` or `receipt_verify`, and it does not state prerequisites, uniqueness constraints, or when an entry is valid.

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 correctly surfaces an important behavioral quirk: one table uses clean play and one flips 5% of moves randomly. However, it does not state whether the call is read-only, whether repeated calls are deterministic, or any other 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?

One compact sentence that puts the main action first and adds the random-flip detail without filler. Every word contributes to understanding 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?

The description explains what is returned but not the table's structure, how to interpret the flipped version, or whether prior actions such as tournament_enter are needed. For a simple no-parameter tool this is adequate but leaves details to 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?

The tool takes zero parameters and the schema is already complete, so the description has no parameter burden. This satisfies the baseline for a parameterless tool.

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

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

The description uses a clear verb ('Returns') and names the resource (ranked table) with the tool's evident purpose. It also distinguishes the two output variants, making the purpose specific, though it does not explicitly compare it to 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 given about when to call this tool, whether tournament entry is required first, or how it compares to alternatives like tournament_enter. Usage must be inferred from the name.

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 behavioral burden. It reveals the output behavior ('Returns whether the answer was accepted and the next step') and the special case of a signed receipt after the fifth step, which is meaningful. It does not discuss side effects deeper than 'submits', but it provides more detail than most tool descriptions.

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

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

The description is two sentences with every word earning its place. The main purpose is front-loaded, and the return behavior is succinctly summarized without unnecessary detail.

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

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

The description covers the return value and the special case well, but it leaves the 'started' parameter unexplained and does not situate itself within the trail flow (e.g., mentioning that 'started' comes from trail_start). For this tool, an agent could infer the fields, but the missing explanation of 'started' is a notable gap.

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

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

Schema description coverage is 0% and the description merely repeats that step, answer, and started are required and name is optional. It adds no meaning for 'started' (a number parameter) and doesn't clarify what 'answer' format or 'step' refers to beyond the names themselves. The description does not compensate for the schema gap.

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

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

The description states a specific action and resource ('Submits an answer to one step'), which clearly distinguishes it from trail_start and other trail-related siblings. It doesn't explicitly name alternatives, but the step scope and trail naming make the purpose unambiguous.

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

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

The description implies when this tool should be used: when a user has an answer to a step and needs to submit it. It does not explicitly contrast it with alternatives like question_answer, nor does it mention when not to use it, so the guidance is implied rather than explicit.

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

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

No annotations are provided, so the description bears the full burden of disclosing behavior. It states it returns data but does not clarify whether this is a pure read operation, whether it has side effects (e.g., starting a session), or any authentication/state requirements. The tool appears read-only but this is not explicitly stated, leaving ambiguity.

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

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

The description is a single, concise sentence that front-loads the action and key outputs. It is appropriately sized for a simple tool, though it could be slightly more structured to highlight the two return components (steps and started value). No wasted words.

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

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

With no output schema, the description must explain the return format, but it only says 'first of five steps' and 'started value' without detailing what a step looks like or the structure of the started value. This is insufficient for an agent to know exactly what to expect. Additionally, it doesn't clarify if there are any prerequisites or side effects.

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

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

The tool has zero parameters, so the schema fully covers them (100% coverage). The description adds no parameter details, but none are needed. The baseline for zero parameters is 4, and the description does not detract from that.

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

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

The description states a clear action: 'Returns the first of five steps and a started value'. It identifies the resource (steps and a started value) and implies a starting point for a trail. It does not explicitly differentiate from siblings like trail_answer, but the mention of 'first' and 'send back with each answer' clarifies its role as an initiation step.

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: call this first to obtain a value to send with subsequent answers. However, it does not explicitly state when not to use it or mention alternative tools (e.g., trail_answer for submitting answers). The guidance is implicit rather than explicit, which is acceptable but not fully fleshed out.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It does not disclose return format, whether counts are live or cached, pagination, or any side effects (though implied read-only). It mentions 'recent' but doesn't define the time window, leaving agents uncertain about data scope. This is a notable gap for a data-reporting 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 a single, compact sentence that front-loads the core action ('Returns counts') and enumerates the grouping dimensions efficiently. It avoids redundancy and is appropriately sized for a zero-parameter tool, though the list of dimensions is slightly wordy but acceptable.

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

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

Given the tool has no input schema, no output schema, and no annotations, the description is the only source of context. It explains what data is aggregated but lacks details on the response structure (e.g., JSON format, fields), the definition of 'recent,' and whether any states are mutually exclusive. For an overview tool, this is adequate but leaves room for misinterpretation about the exact output shape.

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

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

The tool has zero parameters, and schema description coverage is 100% (vacuous). The description adds meaning by explaining what counts are returned and on what dimensions, which is beyond the empty schema. Since there are no parameters to explain, a high baseline is appropriate; the description compensates fully by describing the output groupings.

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

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

The description states a specific verb ('Returns counts') and a resource ('recent requests'), listing four distinct grouping dimensions. It clearly conveys the tool's purpose of aggregating request data, though it doesn't explicitly differentiate from siblings, which are mostly distinct in name (e.g., jobs_list, locker_index).

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 querying aggregate counts of both room/job activity and locker/name ownership without stating when to use it versus alternatives. It provides context that this tool is for overview queries, but no explicit exclusions or alternative routing. Given the sibling list includes dedicated tools for jobs and lockers, the description doesn't clarify when 'who_else_is_here' is preferable.

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