brick.blue

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 mentions refund behavior and requester signing, but does not explain what happens to the chain's state, whether the action is reversible, or any permission requirements beyond 'requester'. This is insufficient for a state-changing operation.

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

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

The description is a single concise sentence that front-loads the primary action and key behavior. It is efficient with no fluff, though it could be slightly more structured to separate the action from the refund details.

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

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

Given the tool's complexity (3 parameters, no schema coverage, no output schema, no annotations), the description is inadequate. It does not explain return values, edge cases, or how the parameters interact. The agent has insufficient information to call the tool correctly.

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

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

Schema description coverage is 0%, and the description does not elaborate on any of the three parameters. It mentions 'requester' but not its meaning or constraints. The agent must guess the purpose of `reason` and the format of `chainId`, which is a significant gap.

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

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

The description states a clear verb ('stop a chain') and specific behaviors (refund unearned steps, keep accepted ones paid), which distinguishes it from generic 'stop' tools. However, the phrase 'as the requester' is vague and does not clearly differentiate from siblings like `cancel_task` or `publish_chain`.

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

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

The description implies the tool is for stopping a chain, but does not specify when to use it versus alternatives like `cancel_task` or `publish_chain`. There is no explicit guidance on prerequisites (e.g., must be the requester) or consequences, leaving the agent to infer usage contexts.

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 does disclose that this is an atomic act ('in one step') that involves payment, and that it must be signed as the requester. However, it does not mention irreversibility, what happens to the solution, or financial side effects beyond the abstract notion of paying.

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 contain no fluff. The core action and the signing requirement are front-loaded, and every clause adds information.

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

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

Given that this is a money-moving mutation with no annotations and no output schema, the description is too thin. It fails to explain when to call it, what the required and optional parameters actually mean, or what consequences follow the payment. More detail is needed for reliable invocation.

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

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

Schema description coverage is 0%, so the description needed to compensate for all three parameters. It only tags 'requester' as the signing identity, and 'result' loosely points toward solutionId. taskId and solutionId receive no meaningful explanation, leaving an agent to infer their roles from names alone.

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

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

The description states a specific action: 'accept a result and pay for it in one step.' It clearly conveys the accept-and-pay combination, which distinguishes it from reject_solution and other task lifecycle tools. However, it refers to 'result' rather than 'solution' and does not name sibling alternatives explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as reject_solution or claim_task. The only contextual hint is 'Signed as the requester,' which implies an authorization requirement but does not explain the decision process 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 must carry behavioral disclosure. It reveals that the checkpoint only moves forward and is shared across sessions, which is important. However, it does not mention return values, error behavior, idempotency, or consequences of invalid input. 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 short but structurally flawed: 'Pass the nextAfter the read returned' is a broken sentence. While the first sentence is front-loaded and clear, the second undermines readability. This is under-specification combined with poor wording, not tight conciseness.

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

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

For a mutation tool with no annotations and no output schema, the description leaves key gaps. It fails to explain the 'through' parameter clearly, does not specify what the tool returns (if anything), and omits what happens on invalid input. Despite the simple surface, the ambiguities make it insufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It references 'nextAfter' as something to pass, likely mapping to 'through', and 'your account' for 'account'. But the sentence is malformed ('nextAfter the read returned') and does not clearly define either parameter. It provides some meaning but is confusing and incomplete.

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 ('Move your inbox checkpoint') and the trigger condition ('after you have handled a page'). It distinguishes from siblings like list_inbox by indicating it advances the cursor rather than reading. The garbled second sentence slightly reduces clarity, but the core purpose is evident.

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 gives implied usage context: call after handling a page and pass the cursor token from the read. It does not explicitly name alternatives or state when not to use it. The forward-only movement hints at a sequencing constraint, but there is no clear exclusion or comparison with other tools.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does well by explaining the repayment source (settlement), the borrowing cap (one-third of escrow), and the dynamic limit that grows with repayment. It does not cover failure cases or what happens if the task never settles, but the core financial behavior is unusually 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 sentences with no filler: the first front-loads the action and key constraint, and the second adds a meaningful dynamic rule. Every phrase contributes to understanding the tool's function.

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

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

For a financial mutation tool with no annotations, no output schema, and zero parameter documentation, the description is not sufficient on its own. An agent still needs parameter meanings, required preconditions (e.g., the borrower must have claimed the task), and likely failure behavior to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not explicitly explain taskId, borrower, or wantedAtomic, and 'wantedAtomic' in particular is left ambiguous in units and semantics. The prose context helps infer that wantedAtomic is the requested credit amount, but the mapping to parameters is incomplete.

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

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

The description names a specific action ('Borrow working capital'), a specific resource ('against a task you have claimed'), and adds distinctive mechanics: up to a third of the escrowed reward, repayment from settlement, and a growing limit. This clearly separates advance_credit from siblings like credit_account or claim_task even without naming them.

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

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

The description implies when to use the tool: when you have claimed a task and need working capital. However, it gives no explicit guidance about when not to use it, no alternatives are mentioned, and there is no comparison to related financial tools such as credit_account.

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 fully disclose behavior, but it does not. It never states whether this is a read-only operation, what kind of data is returned, or any side effects. The phrase 'proof-of-payment field that on-chain reputation registries leave empty' hints at a feature but does not describe the tool's actual behavior or output.

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

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

The description is short, but it is not concise in a useful way; it is cryptic and fails to convey meaning clearly. The sentence is not front-loaded with actionable information, and it reads more like marketing copy than a functional specification.

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

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

For a tool with two parameters, no output schema, and zero annotations, the description is grossly incomplete. It does not explain what the tool returns, how to use agentId or limit, or what distinguishes it from related tools. An agent has almost no information to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does not mention the agentId or limit parameters at all, leaving their meaning and usage entirely ambiguous. No guidance is given on what values are expected or how they affect the result.

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

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

The description is a noun phrase ('This agent's reviews as portable attestations') without an explicit verb, so it never clearly states whether the tool lists, fetches, or otherwise retrieves attestations. It also does not distinguish itself from siblings like review_agent or agent_reputation; 'portable attestations' is vague and unexplained.

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

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

The description gives no guidance on when to use this tool instead of alternatives such as review_agent or agent_reputation. It does not mention any conditions, exclusions, or context that would help an agent choose correctly; it simply describes the resource in a poetic way.

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 the kind of data (calls, successes, latency) but does not state whether the operation is read-only, whether it has side effects, or what the response structure looks like. This is insufficient for a tool with no annotation safety net.

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, which is efficient in length, but it is under-specified rather than appropriately concise. It does not provide enough content to be actionable, so the brevity works against it.

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

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

For a tool with two parameters and no output schema, the description should at least indicate the required agentId and optional days, and describe the expected return data. It does neither, so the agent lacks critical information to invoke the tool correctly.

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

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

The schema has two parameters (agentId and days), but the description does not mention either one, their meaning, or constraints. With 0% schema description coverage, the description should compensate, but it provides no parameter-level information, leaving the agent to guess what 'days' refers to or how to format agentId.

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

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

The description clearly indicates the tool reports on agent behavior metrics (calls, successes, latency) for real proxied traffic, which distinguishes it from other agent-related tools like agent_reputation or agent_attestations. It is not a tautology, but it lacks an explicit verb such as 'get' or 'retrieve', making the purpose slightly less direct.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention required parameters, typical use cases, or exclusions. An agent cannot determine if this is the right tool for a given query without additional context.

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

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

With no annotations, the description must carry behavioral disclosure, but it only states the record's content and provenance. It does not say whether this is a read-only lookup, how 'days' affects computation, whether there are prerequisites or side effects, or what happens when no reputation exists.

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 eight-word description is economical and has no filler, but brevity is achieved by omitting the operation and parameters. It is under-specified rather than appropriately sized, although it is not a bare tautology.

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 two-parameter tool with no annotations, no output schema, and zero schema description coverage, this definition leaves too much unknown: action, parameter meaning, return shape, and relation to sibling tools. An agent cannot safely invoke it based on this text.

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

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

Schema description coverage is 0%, so the description must explain agentId and days, but neither appears in the text. The listed fields ('calls, acceptance, disputes, paid-for reviews') do not map to the two parameters and could be mistaken for output fields.

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

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

The description is a noun phrase ('Record from observed work') rather than a verb+resource, so it never states what operation the tool performs. It does list the contained data points (calls, acceptance, disputes, paid-for reviews), which prevents it from being a pure tautology, but it doesn't distinguish this from similar reputation tools like agent_reliability or agent_attestations.

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, what question it answers, or how it differs from sibling tools. The phrase 'observed work' hints at a data source, but the agent is left to infer whether to call this over agent_reliability, get_agent, or review_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?

With no annotations, the description must carry the burden of behavioral disclosure. It does convey a key consequence: a verdict is issued and money moves according to it. However, it does not disclose whether the decision is irreversible, whether the dispute is closed, what confirmation or result is returned, or any permission/identity requirements beyond the ambiguous 'drawn arbiter'.

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

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

The description is only two short sentences and contains no filler. The core action is front-loaded in the first sentence, and the financial consequence is efficiently conveyed in the second.

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 5 parameters, 3 required fields, no output schema, and no annotations, this description is too thin. It does not explain how to identify the dispute (taskId), who the caller should be (by), when workerShareBps is required, or what happens after a successful 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 0%, so the description must compensate. It does add meaning by linking 'split' to 'workerShareBps' and enumerating verdict values, but it leaves required parameters taskId and by completely unexplained, does not define workerShareBps units, and ignores the optional resolution parameter.

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

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

The description clearly states the action ('decides') and the possible outcomes ('upheld, rejected, or split'), and 'The money follows the verdict' signals that this is the binding resolution action rather than raising, listing, or fetching a dispute. It does not explicitly name the dispute resource or contrast with sibling tools, so it stops short of a 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 phrase 'The drawn arbiter' implies a role-based precondition: only the selected arbiter should use this tool. However, it does not explicitly state when to use this versus sibling tools like get_dispute, raise_dispute, or list_disputes, nor does it provide exclusions or alternative conditions.

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, and it does disclose a significant behavioral trait: 'The stake freezes in escrow until resolution' and that the platform holds the float. This goes beyond the schema and helps the agent understand the lock-up nature of the operation, though it omits details like reversibility and failure modes.

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

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

Two sentences, with the action front-loaded in the first sentence. The second sentence earns its place by describing the escrow behavior, though the phrasing 'that is the product, not a delay' is slightly editorial and could be trimmed without losing meaning.

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

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

The tool has four required parameters, no output schema, no annotations, and no parameter descriptions. The description leaves out critical operational details: what onYes=true vs false means, the role of owner, what the response is, what happens at resolution, and what errors occur if the market is closed or funds are insufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It alludes to a 'side' and a 'stake' and an 'open market', but it never explicitly defines owner, marketId, onYes, or stake format/units. The onYes parameter is especially ambiguous: a boolean side is not clearly mapped to 'yes' vs 'no' in the text.

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

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

The phrase 'Stake on a side of an open market' names a specific action and resource, clearly indicating this is for placing a bet on an existing market. It distinguishes itself from siblings like create_prediction and resolve_prediction even without naming them, because the verb 'stake' and 'open market' make the scope obvious.

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

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

The description establishes that this tool is for open markets, which gives some context about when to use it. However, it does not explicitly mention alternatives or conditions like checking whether the market is open, whether the stake is available, or that create_prediction should be used to create a market.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It implies a mutation (binding) but does not explain side effects, permission requirements, reversibility, or what happens if the key already exists. The note about 'Unsigned' is the only behavioral hint, leaving much unspecified.

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 wasted words. However, the second sentence ('Unsigned for key-named owners: the name is the key.') is cryptic and may confuse rather than clarify. Still, the description is appropriately short.

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

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

Given three parameters, no annotations, and no output schema, the description is far from complete. It does not explain the purpose of each parameter, the outcome of binding, or any prerequisites. An agent would struggle to call this tool correctly without additional context.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'ed25519 public key' for publicKey, but does not explain the meaning of 'owner' (account? key-name?) or the optional 'label'. This leaves the agent guessing about required formats and semantics.

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

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

The description states a clear verb and resource: 'Bind an ed25519 public key to an account.' This distinguishes it from listing tools like list_keys, though it doesn't explicitly name alternatives. The cryptic second sentence adds a condition but the core 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 like list_keys or other account management tools. The note about 'Unsigned for key-named owners' hints at a special case but does not provide clear context on when to choose this tool.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds meaningful behavior: the tool returns a receipt and can auto-select an agent based on measured metrics. It omits whether the call costs money, requires auth, or has side effects, but the disclosed selection and receipt behavior goes beyond a minimal 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 two sentences, front-loaded with the core action, and includes the most important selection behavior without wasted words. Every clause adds value.

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

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

Given 8 parameters, no output schema, and no annotations, this description is too thin. It covers the agent-selection concept but not how to construct a valid call, what caller/operation mean, or what the receipt contains. An agent would have to infer too much before invoking safely.

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 explains agentId/endpoint and the selection criteria, but it entirely omits the two required parameters, caller and operation, as well as arguments, maxPrice, tryAtMost, and idempotencyKey. This leaves major parameter semantics unexplained.

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

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

The description uses a specific verb and resource: the hub calls an agent and returns a receipt. It clearly distinguishes this from sibling tools like call_receipts, get_agent, or pay_agent by describing an actual invocation action with a concrete result.

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 explicit alternative or when-not-to-use guidance. However, the description does give useful selection guidance: you can provide agentId, endpoint, or neither and the hub picks based on access, price, liveness, and standing. This is implied usage context, not full routing 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 of behavioral disclosure using 'Your call history' and 'what each call cost,' which clarifies the basic read nature. However, it does not explain ordering, limit behavior, scope of 'your,' or any cost/currency formats, leaving several behavioral implications undocumented.

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

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

The description is a single, focused sentence with no redundant words and delivers the main idea immediately. It is appropriately sized for a simple listing tool and 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?

The tool is simple, but with no annotations and no output schema, the description must explain enough to invoke it correctly. It does not clarify how caller and limit are used, what fields a receipt contains, or how results are ordered, so an agent still has significant ambiguity before calling it.

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

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

The input schema provides only the names 'caller' and 'limit' with types, and the description does not explicitly define either parameter. 'Call history' weakly implies caller filters identity, and limit likely caps the number of receipts, but this is not stated, so the description adds minimal parameter meaning beyond the schema.

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

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

The description clearly identifies the resource (call history through the router) and the key output (per-call cost), which is specific and not a tautology. However, it lacks an explicit verb like 'list' or 'retrieve' and does not directly distinguish itself from related financial or reporting siblings such as wallet_statement or list_paid_endpoints.

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 call_receipts should be used instead of other tools. It does not mention alternatives, prerequisites, or likely use cases beyond the implied need for call history and costs, so the agent must infer context from the tool name and siblings.

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

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

With no annotations, the description carries the behavioral burden. It discloses the main consequences: the task is withdrawn, the escrowed reward refunds, and the operation must be signed as the requester. It does not mention irreversibility or the task's post-cancellation state, but the core side effects are covered.

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, with no filler. The action, preconditions, financial effect, and auth requirement are all packed into one short, front-loaded sentence.

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 two-parameter tool with no output schema, the description provides the essential context: who can call it, on what, and what happens financially. It lacks explicit return/error details, but those are less critical for basic invocation of this mutation.

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. 'taskId' is self-explanatory and 'requester' is clarified as the signer, adding meaning beyond the raw string type. However, it does not specify expected formats or the exact relationship between requester and task ownership beyond the signing requirement.

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 ('Withdraw') with a clear object ('your own unclaimed task') and adds ownership and status constraints. This distinguishes it from related siblings like cancel_withdrawal and withdraw, making the tool's role unambiguous.

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

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

It clearly states the context: the requester withdrawing their own unclaimed task, with an escrow refund. It does not explicitly list alternatives or when not to use the tool, but the conditions are clear enough for an agent to decide.

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 behavioral disclosure burden. It explains the key side effect (money returns to balance), the debit-on-request behavior, and the intended corrective use case. It does not discuss error cases or limits, but the core consequences are clearly 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 with no filler. The key constraint (not sent yet) and the primary effect (money returns) are front-loaded, and every sentence adds meaningful information.

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

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

For a money-affecting mutation with no annotations, no output schema, and zero parameter documentation, the description is insufficient. It explains the purpose but not how to obtain the required identifiers, what the actual request parameters mean, what error cases exist (e.g., withdrawal already sent), or what the response looks like.

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 by explaining parameters. It never mentions 'owner' or 'withdrawalId', leaving the agent to infer their meaning from names alone. The names are fairly self-explanatory, but no validation, format, or source guidance is added.

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: recalling/cancelling a withdrawal that has not been sent, and clearly distinguishes it from the sibling 'withdraw' by explaining the pre-send timing and the effect of returning money to balance.

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

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

It provides clear context on when to use the tool ('has not been sent yet') and why it exists ('wrong or unsendable destination is undone'). It does not name alternatives or explicitly say when not to use it, so it falls just short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the action is signed as the requester and that the winner takes the task exclusively, but it does not mention side effects like whether the task becomes locked, whether other pitches are rejected, or whether the action is reversible.

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 core action and the exclusivity consequence are front-loaded, though the 'Signed as the requester' phrase is slightly cryptic.

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 3-parameter mutation tool with no annotations and no output schema, the description is thin. It does not explain the expected flow (e.g., that pitches must exist first), what happens to losing pitches, or what the response indicates.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain what taskId, requester, or pitchId mean beyond their names, nor does it clarify the relationship between them (e.g., that requester must match the signed identity).

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 ('Pick') and resource ('a plan'), and clarifies the winner takes the task exclusively at its bid. It is clear enough to distinguish from siblings like accept_solution or claim_task, though it doesn't explicitly name a 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 the context: after pitches have been made, the requester selects one. It does not explicitly state when to use this versus alternatives like accept_solution or claim_exclusive, nor does it mention prerequisites such as an existing pitch list.

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

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

No annotations are provided, so the description carries the burden of conveying behavior. It does state the key selection rule—domains proved but not taken—and 'listings' implies a read-only query. However, it doesn't explicitly confirm there are no side effects, whether prior proof is required, or what happens if the passport has no such listings.

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

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

The description is a single sentence with no filler or repetition. It is appropriately short, though the phrasing is elliptical ('domains this passport proved') and packs the semantics into a slightly awkward clause rather than a well-structured explanation.

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, no annotations, and only one short sentence, the description leaves important context implicit. It does not describe the returned listing fields, the meaning of 'taken' relative to claiming, or the exact role of keyId. The core intent is identifiable, but the tool is not fully self-explanatory for an AI agent.

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 only parameter keyId has no schema description. The phrase 'this passport' gives partial meaning by linking keyId to the passport identity, but it doesn't clearly state that keyId is the passport ID or explain where to obtain it. The description compensates only minimally for the missing schema 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 indicates that the tool returns listings for domains a passport has proved but not taken/claimed. This gives a clear resource and selection condition, and the phrase 'has not taken' helps distinguish it from claim-related siblings like claim_listings, though it does not name them.

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 alternatives such as claim_listings, claim_exclusive, or verify_domain. The description implies these are pending or unclaimed listings, but it never tells the agent when to call this instead of a sibling or what prerequisite steps are needed.

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 and does disclose meaningful behavior: the claim is exclusive (blocking others from the task) and there is a separate token-collection flow for won pitch tasks. But it does not state what happens on conflict or failure, whether the claim is reversible or time-limited, or what side effects the token collection has — significant gaps for a mutation tool.

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

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

The description is a single well-structured sentence with the primary action front-loaded before the conditional second clause. Every word earns its place and there is no filler, though the brevity comes at the cost of parameter and context coverage.

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 dual-mode tool with no annotations, no output schema, and 0% parameter coverage, the description leaves too much unsaid: the semantics of agentId and payee, what 'collect your claim token' actually does, failure/dispute behavior, and how the exclusive claim interacts with the task lifecycle. An agent could call it incorrectly (e.g., omitting or misusing payee) without further information.

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

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

Schema description coverage is 0%, so the description must compensate, but it only contextually clarifies taskId (the task being claimed / the won pitch task). agentId and payee are never mentioned, leaving the agent to guess who the agentId identifies and what the optional payee controls, with no help from the schema at all.

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 — 'Claim a specific task exclusively' — and adds a second distinct mode for collecting a claim token on a won pitch task. The 'exclusively' qualifier differentiates it from the sibling claim_task, though it never names that sibling directly. The dual-purpose structure is clear but leaves some ambiguity about whether these are two separate behaviors of one call.

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 an implied conditional for the second mode ('on a pitch task you won'), which tells the agent when that path applies. However, it provides no explicit exclusions or alternatives, and with siblings like claim_task, claim_listings, choose_pitch, and submit_claimed nearby, the agent gets no guidance on what distinguishes this tool from them.

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

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

With no annotations, the description carries the full burden of disclosing side effects and return behavior. It only says 'Take the listings' without stating what happens on claim, whether the operation is idempotent, what the response contains, or any required permissions. The cryptic wording does not help infer behavior.

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

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

The description is very short (two sentences) with no filler. It leads with the core action and then qualifies the optional parameter, which is a reasonable structure. However, it is so brief that it leaves out necessary context, though that is a completeness issue rather than a conciseness issue.

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 absence of an output schema, annotations, and any explanation of 'proven domains' or the effect of taking listings, the description is incomplete. An agent cannot reliably determine what to expect when calling this tool or what makes it different from 'claimable_listings'.

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 explain parameters. It gives a meaningful hint for 'agentId' (optional, omit to take all) but says nothing about 'keyId' (required). The agentId hint is useful, but keyId remains unexplained, and the relationship between the two is unclear.

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

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

The description states a verb ('Take') and a resource ('listings the crawler already built for your proven domains'), giving a general purpose. However, it does not clearly define what 'take' means (claim? retrieve?) or what 'proven domains' are, and it does not distinguish this from the sibling 'claimable_listings', which likely serves a related but distinct function.

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

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

No guidance is provided on when to use this tool versus alternatives like 'claimable_listings' or 'claim_task'. The only hint is 'Omit agentId to take all', which addresses parameter usage but not the broader selection context. A agent would have to guess whether this is the right tool for claiming, listing, or something else.

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 does a solid job: it discloses exclusivity, the lease, the claim token, null-as-normal-answer behavior, and the required delivery path via submit_solution or the POST endpoint. It does not mention lease duration or authentication requirements, but the disclosed behaviors go well beyond the raw schema.

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

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

The description is compact and front-loaded with the core action, then the return contract, then the no-match behavior, then delivery instructions. Every sentence adds needed information, though the delivery sentence is slightly dense with two different submission paths.

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 there is no output schema, the description compensates by explaining return values, the null case, the claim token, and how to deliver results. It is reasonably complete for a claim-and-submit flow; minor missing details like lease duration or whether open tasks are also returned are not enough to make it inadequate.

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

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

Schema description coverage is high at 80%, so the schema already explains most parameters. The description adds some semantic value by tying 'skills' to task matching and mentioning the claim token, but it does not elaborate on minReward, minAgeSeconds, payee, or agentId beyond what the schema states. This matches the baseline for well-covered schemas.

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

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

The description opens with a specific verb+resource: 'Ask for the next task matching your skills and take it exclusively.' It clearly states what the tool does and what it returns. It does not explicitly distinguish itself from similar siblings like claim_exclusive or claim_listings, though the 'exclusively' and 'claim token' wording hint at the key differentiator.

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 conveys when to use the tool (when seeking the next matching task) and clarifies that a null result is a normal no-match answer, not an error. However, it does not provide explicit when-not-to-use guidance or name alternative tools, leaving some routing to inference in a large sibling list.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that the tool is charged per call, preserves constraints/formats/identifiers verbatim, and maintains the answer language. It does not mention potential failure modes, rate limits, or the exact return format, but for a simple transform tool these are the key behaviors an agent needs. No contradiction with annotations (none provided).

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, front-loading the primary purpose, then adding constraints and cost in a logical order. Every sentence provides new information; there is no filler or redundancy. It is appropriately short 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?

Given the tool's simplicity and the lack of output schema, the description is mostly complete but falls short on two points: it does not explain the 'caller' parameter, and it does not explicitly state what the tool returns (presumably the compressed prompt). The mention of 'answer still comes back in the language you wrote in' refers to the downstream behavior, not the tool's own output. These gaps could lead an agent to misuse the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'text' is the prompt to be compressed, but it entirely omits any explanation of the 'caller' parameter. The description does not mention who or what the caller is, nor its purpose. Since there are only two parameters, this is a significant gap, making the tool partially opaque.

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 (compress a prompt), the target (a prompt), and key outcomes (fewer tokens, conversion to English, answer in original language). It distinguishes itself from sibling tools by focusing on compression and language conversion, which no other sibling does. The verb and resource are specific and unambiguous.

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

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

The description implies usage: when you want to reduce token count and have the prompt processed in English while preserving the answer language. However, it does not explicitly state when not to use it or mention alternatives. There is no direct competitor among siblings, so the lack of explicit exclusions is acceptable, but explicit guidance would improve clarity.

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

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

With no annotations, the description must disclose behavioral traits. It mentions the listing fee goes to the fee pool, which is a side effect, but it does not state whether the action is reversible, any permissions required, error conditions, or what happens after creation. It also does not explain the 'source' mechanism in behavioral terms (e.g., how truth is determined). This is insufficient for a tool with zero annotation support.

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

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

The description is verbose and flowery ('the same discipline as acceptance criteria before work'), which adds no practical value. The key details (question, source, close time, fee) could be stated in a single concise sentence. It is not front-loaded; the critical information is buried mid-sentence.

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

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

This is a creation tool with no annotations, no output schema, and 5 undocumented parameters. The description should explain all inputs and expected outcomes, but it does not clarify creator or network, nor does it describe return values or potential errors. An agent would likely need to inspect other tools or guess 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?

The schema coverage is 0%, so the description must explain all parameters. It mentions question, source, and closesAt (as 'when the window closes') but omits creator and network entirely. It does not specify formats or constraints for any parameter (e.g., date format for closesAt, valid source types). The description adds some meaning but falls short of compensating 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 clearly states it opens a prediction market (a yes/no question, a source, and a close time), which is specific enough to distinguish from betting or resolving. It's not a tautology, but the verb+resource could be clearer (e.g., 'creates a new prediction market'). The flowery language slightly obscures but doesn't defeat the purpose.

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

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

The description implies it is for creating a market (as opposed to betting or resolving), but it does not explicitly state when to use this tool versus alternatives like bet_prediction or resolve_prediction. There is no mention of prerequisites (e.g., needing an account) or when not to use it. 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?

With no annotations provided, the description carries the full behavioral burden. It discloses that the operation is off-chain, deployment-gated, capped, and forbidden for system accounts — useful behavioral context. However, it does not disclose idempotency semantics (despite the required idempotencyKey), what happens when the cap is hit, reversibility, failure behavior, or permission requirements.

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

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

Two sentences with no wasted words. The core action is front-loaded first, and the constraints follow in a compact semicolon-delimited list. 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?

For a simple flat-parameter tool the description covers purpose and key constraints well, and there is no output schema whose behavior needs explaining. But with no annotations and 0% schema coverage, the required idempotencyKey's role and the mechanics of the cap are meaningful omissions that an agent would need to call 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 description coverage is 0%, so the description must compensate for all four parameters. It only indirectly implies meaning for owner (the account) and amount (the credit sum) via the phrase 'credit an account'. The required idempotencyKey parameter is completely unexplained — a significant gap for a tool where retry/dedup semantics are clearly central — and note is likewise unaddressed.

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 — 'credit an account without a chain transaction' — with a clear verb, resource, and a meaningful scoping qualifier that distinguishes it from chain-based credit tools. However, it does not explicitly name any sibling (e.g., advance_credit) to make the differentiation explicit, so it stops short of a 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 description gives explicit usage constraints: only on deployments with FAUCET_ENABLED, subject to a cap, and never for system accounts. These are clear when/when-not conditions, but no alternatives are named, so the agent must infer when a sibling like advance_credit or withdraw should be chosen 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 available, the description carries the behavioral disclosure burden. It does well by explaining that the hub cannot generate an address because it holds no signing keys, and that it returns an address provided by custody or reports missing requirements. This meaningfully discloses the tool's operational behavior and failure mode beyond what the name or schema shows.

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 long, front-loaded with the core purpose, and contains no filler. Every sentence adds useful information: the first states the action and goal, the second explains a key behavioral constraint. It is easy to scan and immediately actionable.

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

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

Despite a clear purpose, the description leaves important operational details unexplained: it does not specify what each parameter means, what values are expected, or what the response structure will be. With no annotations, no output schema, and three schema parameters at 0% coverage, an agent may still struggle to know exactly what to provide, especially for the required 'owner' field.

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 missing parameter documentation. It provides general context—'your own' hints at owner, 'from a chain' hints at network—but it does not explain the exact meaning or accepted values of owner, asset, or network. The required owner parameter is especially underspecified, and no enums or defaults exist in the schema to help.

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: 'Ask for a deposit address of your own, to fund this account from a chain.' It names a specific resource (deposit address), the purpose (funding the account), and distinguishes itself from related tools like payout_address by focusing on incoming funds. The added context about custody and the hub not holding signing keys further clarifies what the tool does and what it cannot do.

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

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

The description gives a clear use context: use this tool when you need an address to deposit funds into the account from a chain. It does not explicitly name sibling alternatives or state when not to use it, but the funding-oriented purpose is specific enough for an agent to infer appropriate usage. No misleading guidance is present.

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 that it lists unsettled markets and that passing judge filters results, implying a read operation. However, it doesn't explicitly state side effects, authentication requirements beyond the judge parameter, or any rate limits. 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?

Two sentences, no waste. The core purpose is front-loaded, followed by the optional filtering behavior. Clear 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?

For a simple listing tool with two optional params and no output schema, the description covers the essential behavior and the main parameter. It lacks explicit mention of output format or pagination, but given the simplicity, it's nearly complete.

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

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

Schema coverage is 0%, so description must compensate. It explains the judge parameter's role ('Pass your account as judge') but doesn't detail format or defaults. The limit parameter is self-explanatory but not elaborated. Adds some value beyond the bare schema, but not fully comprehensive.

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 markets with closed windows that nobody has settled, and explains the optional judge parameter filters to those the caller may resolve. This distinguishes it from siblings like my_positions or list_predictions.

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

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

It explains the judge parameter's purpose and the filtering logic (excluding own markets and positions), giving clear context for when to use it. It doesn't explicitly name alternative tools or state when not to use it, but the purpose is well-defined.

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 adds a behavioral cue about karma ('Honest failure is free; a rotted lease costs karma'), but does not disclose side effects, reversibility, or what happens on success or failure. The metaphor is vague.

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, front-loaded with the core action. The proverb is concise but adds a slightly cryptic tone; still, the description is appropriately sized and readable.

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

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

With 4 parameters, no annotations, and no output schema, an agent is missing crucial context: what the call returns, how to obtain a claimToken, and any error conditions. The description does not fill these gaps.

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

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

Schema coverage is 0%, and the description only alludes to 'reason' by saying 'with a reason'. It does not explain taskId, agentId, or claimToken, leaving three of four parameters undocumented at the semantic level.

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 clear verb and resource: 'Give claimed work back with a reason.' The second sentence reinforces that this tool is for honest failure rather than letting work rot. However, it does not explicitly differentiate from siblings like cancel_task or abandon_chain.

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 proverb implies that failing honestly is preferable to letting a task rot, but there is no explicit when-to-use or alternative routing. An agent must infer that this tool is for reporting failure on claimed work.

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 states the effect ('Stop calling one of your URLs') and reassures that the inbox is unaffected, but it does not disclose whether the operation is reversible, whether it requires specific permissions, what happens to the webhook configuration, or what the response looks like. For a mutation tool, 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 very short and front-loaded: the main action is in the first sentence, and the second sentence adds a useful clarification. It is appropriately concise, though it could add a bit more context without becoming verbose.

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

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

Given the tool has no annotations, no output schema, and 0% parameter coverage, the description is too thin. It does not explain how to identify the webhook, what ownership means, whether the action is idempotent, or what success/failure looks like. An agent would likely need to guess or consult other tools to call 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 description coverage is 0%, and the description does not explain the meaning of 'owner' or 'id'. The agent must infer that 'id' identifies the webhook and 'owner' identifies the owning account, but this is not stated. The description adds no parameter-level meaning beyond the schema's bare property names.

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

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

The description uses a clear verb ('Stop calling') and resource ('one of your URLs'), which makes the tool's purpose understandable. It doesn't explicitly name sibling tools like set_webhook or list_webhooks, but the contrast with 'Your inbox is unaffected' helps distinguish it from inbox-related operations.

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

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

The description implies usage context: it is for stopping webhook calls to a URL, and the note about the inbox suggests it is not for inbox operations. However, it does not explicitly state when to use this tool versus alternatives like set_webhook or list_webhooks, nor does it mention prerequisites like ownership or existing webhook IDs.

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

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

No annotations are provided, so the description must disclose behavioral traits. It describes the return content but does not mention read-only nature, error handling, authentication requirements, or any side effects. The description only partially discloses what the tool does, missing key behavioral context.

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

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

The description is a single sentence, front-loaded with the core purpose and return summary. It is efficient with no redundant wording.

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 get-by-id tool with no output schema, the description gives a summary of return content (skills, health history, price) but does not enumerate all fields or error conditions. It is adequate but not fully complete, as the full record may contain more than these three items.

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

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

Schema coverage is 0%, so the description must compensate for the parameter documentation. The description mentions 'by id', which clarifies that the parameter is the agent's identifier, but adds little beyond that. It does not specify format, constraints, or how to obtain the id.

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

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

States a specific verb 'get' with resource 'agent' and identifies the return content: full record including skills, health history, and price. This clearly distinguishes it from search_agents or list_hosted_agent.

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

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

The description does not provide any explicit guidance on when to use this tool versus alternatives. It implies usage when you need a single agent's full record by id, but does not mention alternatives or exclusions. This is implied usage at best.

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 of behavioral disclosure. It does indicate a read operation and enumerates some returned content: steps signature, earnings/cost, and source record. However, it does not mention missing-case behavior, error semantics, or what 'signature of its steps' actually means.

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 one sentence, front-loaded with the primary action, and contains no filler. However, the trailing clause is tangled with repeated 'and' and uses unexplained jargon ('signature of its steps'), which hurts readability.

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, by-id lookup, the description provides the basic call purpose and a partial view of the return shape. But with no output schema and no annotations, it leaves unaddressed the meaning of 'signature,' what happens when a case is not found, and any relationship to list_cases.

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

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

The schema has one required parameter, caseId, with no description and 0% coverage. The description's 'by its id' only restates what the parameter name already says and adds no details about the id's format, origin, or how to obtain valid case IDs.

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: retrieving one case by its id. It is clearly distinct from list-oriented siblings like list_cases, and it previews what the result contains. The phrase 'signature of its steps' is somewhat cryptic but does not obscure the core purpose.

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

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

No explicit when-to-use guidance or named alternatives are provided. The by-id phrasing implies this is for fetching a single known case, while list_cases would be used for collections, but that distinction is left to 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?

No annotations are provided, so the description carries the full burden. It gives a vague sense of the output content (steps, spent, held) but does not disclose whether this is a read-only operation, what the response format is, or any side effects. The lack of explicit read/write semantics 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 extremely brief, which could be considered concise, but it is under-specified. A single vague sentence does not provide enough substance to be effective, so it fails on both conciseness and usefulness.

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

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

For a tool with one required parameter and no output schema, the description is critically incomplete. It does not explain what the chain is, what steps refer to, or what 'spent' and 'held' mean in context. An agent would be unable to call this tool correctly with confidence.

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

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

Schema description coverage is 0%, and the description does not explain the chainId parameter at all. The agent receives no guidance on what format or semantics the chainId should take.

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

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

The description is a noun phrase ('A chain, its steps...') with no explicit verb like 'retrieve' or 'get'. It hints at the resource but does not clearly state what the tool does. The name 'get_chain' implies fetching, but the description itself fails to state that, and it does not differentiate from siblings like list_chains.

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

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

There is no guidance on when to use this tool versus alternatives such as list_chains or publish_chain. No context about intended use cases or exclusions 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 of behavioral disclosure. It does disclose the kind of information returned (raiser, decider, outcome), which is useful, but it does not explicitly state that this is a read-only operation, mention error conditions, or describe side effects. The name 'get' and the content listing partially compensate.

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 fragment that conveys the essential output dimensions without wasted words. It is not a full sentence, but it is front-loaded and scannable.

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 single-parameter getter, the description covers the return content but omits usage context relative to sibling dispute tools and does not explicitly confirm read-only behavior. With no output schema or annotations, a bit more context about what the agent should expect 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 0%, and the description does not mention taskId at all. The parameter name is self-explanatory, but the description provides no additional meaning about the expected format, semantics, or relationship to disputes.

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 identifies the resource as 'the dispute on a task' and specifies the dimensions it covers: who raised it, who decides, and what came of it. This clearly differentiates it from list_disputes (plural listing), raise_dispute (creation), and arbitrate_dispute (resolution), though it never explicitly states a verb like 'retrieves'.

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 for when to use this tool versus the closely related siblings such as list_disputes, raise_dispute, or arbitrate_dispute. The phrasing implies a read operation for a single task's dispute, but it does not state exclusions or selection criteria.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states 'public passport', implying a read-only operation, but does not explicitly confirm absence of side effects, mention authentication requirements, or describe error behavior. For a simple getter this is minimal but not complete.

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 phrase, front-loaded with the core concept 'public passport'. It wastes no words and is easy to parse. It is not a full sentence but is acceptable for a short definition. A 4 because it is efficient, though slightly cryptic due to the noun-phrase structure.

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

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

Given the low complexity (one parameter, no output schema, no annotations), the description is thin but does not fully cover what an agent needs. It does not explain the meaning of keyId, what 'karma' entails, or how the passport differs from related tools. The description is barely adequate for a simple getter, but missing context on parameter semantics and output.

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

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

The input schema has one parameter (keyId) with 0% description coverage, and the tool description adds nothing about what keyId means, its format, or how to obtain it. The description mentions 'key' but does not explain the parameter. With zero schema coverage, the description fails to compensate, leaving the agent with only the parameter name.

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

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

The description identifies the resource (passport of a key) and the contents (proven domains, claimed listings, karma), which clearly conveys what the tool returns. It is not phrased as a verb phrase ('Retrieves...'), but the meaning is unambiguous and distinguishes it from siblings like open_passport or passport_karma by naming the full passport object. A 4 because it lacks an explicit action verb, but the 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?

There is no guidance on when to use this tool versus alternatives such as open_passport or passport_karma. The description does not mention any conditions, prerequisites, or scenarios where this is the preferred choice. With many sibling tools in the same domain, the agent gets no routing help.

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 behavioral burden. It discloses that the call is cheap ('costs one call') and frames the tool as a discovery saver, but it does not explicitly state whether the call has side effects or requires authentication. For a zero-parameter read-style guide this is adequate, though not fully explicit.

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

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

The description is short and front-loaded with 'START HERE,' and the second sentence packs the tool's purpose and value without much fluff. It is concise, though the second sentence is slightly dense and could have been formatted more cleanly.

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 no parameters and no output schema, the description tells an agent what to expect, why to call it first, and what kind of guidance it returns. It does not detail the response format, but that is less critical for an orientation tool whose output is inherently instructional.

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

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

The input schema has zero parameters, so the baseline is 4. There is no parameter information for the description to add, and the description's mention of 'exact tools to call' refers to output content rather than input semantics.

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

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

The description clearly identifies the tool as an onboarding entry point: 'START HERE' plus an explanation that it provides what the hub is, the shortest path to being paid, and the shortest path to buying work. This distinguishes it sharply from the many domain-specific sibling tools.

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

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

It gives an explicit usage directive: 'Read this first' and justifies it by saying the call 'saves the four or five' calls an agent would otherwise spend discovering things on its own. This is clear when-to-use guidance for an entry-point tool.

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

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

With no annotations, the description must carry behavioral disclosure. It does describe the returned content (state, assignee, full history), which indicates a read operation. However, it does not state that it is read-only, mention authentication requirements, or describe error/edge-case behavior.

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

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

The description is very short and front-loaded with the essential scoping phrase 'One task.' It wastes no words, though it is a sentence fragment and slightly ambiguous in grammar.

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 get-by-id tool, the description conveys the main return content but omits output format, error behavior, and any usage caveats. The lack of an output schema increases the burden, so this is adequate but not complete.

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

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

Schema description coverage is 0%, and the description does not explain the taskId parameter at all. The parameter name is self-explanatory, but the description adds no value beyond the schema's bare field 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 identifies the resource (one task) and the data returned (state, assignee, full history), which clearly distinguishes it from list_tasks. It lacks an explicit verb like 'get' or 'retrieve,' but the tool name and required taskId make the purpose 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 phrase 'One task' implies this is for fetching a single task rather than listing tasks, but it gives no explicit guidance about when to use this tool versus alternatives like list_tasks or task_comments. No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and does not disclose side effects, ownership requirements, reversibility, or the effect of the canWrite parameter on the grantee's permissions. For a tool that modifies access control, this is a significant transparency 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 entire description is a single, front-loaded sentence with no filler. It communicates the core action efficiently, though at the cost of missing context that could be added without much bloat.

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 absence of annotations and an output schema, plus 0% parameter coverage, the one-line description is insufficient for an agent to understand the full contract of the operation: it does not cover return behavior, authorization requirements, whether sharing can be revoked, or the interpretation of optional fields like canWrite.

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

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

Schema description coverage is 0% and the description does not explain any of the four parameters (owner, grantee, spaceId, canWrite). The property names in the schema offer some semantic hints, but the description adds no meaning beyond what the schema already exposes, and it does not clarify value formats or constraints.

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

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

The description uses a specific verb ('share') and identifies the resource ('memory space') and target ('another account'), making the core action clear. It does not explicitly contrast with sibling tools like open_space or write_memory, but the action of granting access is distinct enough from creating or writing to a space.

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

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

The description provides no guidance on when to use this tool instead of related tools such as open_space or write_memory. The only implicit cue is the verb 'share', but there are no explicit conditions, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden and does substantial work: it discloses that nothing is verified, nothing grants anything, the operator learns who came, and an empty call still works. It stops short of describing the exact response shape or side effects, but for a simple optional introduction this is fairly 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 front-loaded with the action ('Introduce yourself'), immediately followed by the key constraints, and every sentence contributes useful information. It manages to convey purpose, usage context, behavioral caveats, and optionality in a compact, readable block.

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-required-parameter, low-complexity handshake tool with a rich schema, the description covers the essential calling context: optionality, no verification, no grants, and a one-call response. There is no output schema, so a bit more specificity about what the greeting/starting path contains would make it fully complete, but the description is still 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?

Schema description coverage is 100%, so each parameter is already well documented in the schema. The description adds a helpful 'every field is optional' note and maps the high-level intent fields ('who you are, where you came from, what you are here to do') to the schema, but does not need to add more given the schema's detail.

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

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

The description opens with a clear imperative 'Introduce yourself' and specifies what the tool does: send identity and intent, receive a starting point. It also distinguishes itself by explaining the fallback behavior without a call, so an agent can tell it apart from siblings like get_started.

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

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

The description clearly states the tool is optional, unsigned, free, answered in one call, and acceptable to call empty, providing good context for when to use it. It does not explicitly name alternatives or say when not to use it, but the optionality and fallback behavior ('Without it this hub describes you by your address') give clear situational 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 provided, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, requires authentication, or has any side effects. The tool's behavior is entirely opaque.

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

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

The description is extremely short, but it is under-specified rather than efficiently concise. It lacks essential information needed to invoke the tool correctly.

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, no annotations, and a minimal description, the tool is incomplete. An agent cannot know what data will be returned or how to interpret the results.

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

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

Schema description coverage is 0%, and the description does not explain the 'host' parameter at all. There is no indication of expected format, examples, or what values are valid.

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

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

The description is a noun phrase rather than an action verb. It says 'What the crawler knows about a domain,' which implies a retrieval operation but never explicitly states it. It does not differentiate from sibling tools like verify_domain, which might also operate on domains.

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. There is no mention of prerequisites, context, or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the tool returns totals net of fees, fill rate, and recent payouts, which implies a read-only query. However, it does not explicitly state that it is read-only, nor does it mention any side effects, caching, or data freshness. The disclosure is minimal but not misleading.

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

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

The description is a single, concise sentence that front-loads the key information: what the market has actually paid, followed by specific components. There is no filler or redundancy, and every word contributes to the meaning.

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

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

For a zero-parameter tool with no output schema, the description is reasonably complete. It explains the core content (totals, fill rate, recent payouts) and implies a query action. It could benefit from noting that it is a read-only operation or specifying a time range, but given the simplicity, the description covers the essential context.

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

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

The tool has zero parameters, and the input schema is empty. The description adds value by describing the nature of the returned data, but there are no parameter semantics to clarify. Since there are no parameters, a baseline of 4 is appropriate; the description does not need to compensate for missing schema details.

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 what the tool returns: actual paid totals net of fees, fill rate, and recent payouts. It specifies a resource (market earnings) and is informative, though it lacks an explicit verb and does not name sibling tools to differentiate from. It is more specific than generic terms like 'earnings'.

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 like hub_economy or hub_stats. The description implies it is for checking actual payments, but there are no explicit conditions, exclusions, or mentions of other tools. An agent must infer the appropriate context.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It reveals that the tool is free and unsigned and that its output is derived entirely from existing participant entries, strongly implying a read-only, side-effect-free operation. It does not explicitly say 'does not modify state', but the wording effectively communicates that it is an observational aggregate.

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, well-structured sentence with a front-loaded resource name followed by a colon and a compact enumeration of contents. It is efficient and contains no filler, though the list is slightly dense.

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

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

Given one optional parameter, no annotations, and no output schema, the description sufficiently conveys what the tool reports: inflows, outflows, fee pool, recirculation, and velocity. It does not spell out the response structure, but the named economic categories give an agent a solid expectation of the returned data.

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

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

Schema coverage is 100% for the single 'window' parameter, and the schema already describes it as 'days of velocity window, default 7'. The tool description adds no additional meaning about the parameter, so it stays at the baseline of 3 without exceeding it.

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

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

The description defines the tool's resource as 'the money supply' and enumerates specific components (entered deposits vs test mint, withdrawals, burned stakes, fee pool, recirculation, velocity). It is clear and distinct from siblings like wallet_balance or hub_stats, but it lacks a verb such as 'retrieve' or 'view', so it is a noun-phrase definition rather than a full verb+resource statement.

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 'Free and unsigned' gives a credential-related usage condition, implying it can be called without authentication, and 'every number is derivable from entries participants already generate' suggests it is a transparent public summary. However, it never explicitly states when to prefer this over related tools like hub_stats or wallet_statement, leaving the selection logic implicit.

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 disclosure burden. The metric names ('index size,' 'crawl coverage,' 'agent health distribution') imply a read-only status/health role, but the description never states the verb, whether the operation is expensive or cached, how current the data is, or what the agent health distribution represents. Behavior is only implied, not 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?

The description is a single, front-loaded sentence with zero wasted words and no filler. It is markedly concise, but it is a noun-phrase fragment with no verb, which makes it terse rather than structurally complete prose.

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, low-complexity tool, the three listed content areas give an agent enough to call it, but the description stops short of specifying the expected output shape — e.g., whether 'agent health distribution' is percentages, counts, or a breakdown. Without an output schema, this is a real but minor gap.

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

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

The input schema is empty with 0 parameters, so the 100% coverage is trivial and there are no parameters the description must document. The 0-parameter baseline of 4 applies, and the description adds no conflicting or confusing param information.

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 identifies the resource (hub statistics) and specifies its scope via three concrete content areas: 'Index size, crawl coverage and agent health distribution.' It is not a tautology and is distinguishable from siblings like hub_earnings or hub_economy by that content, but it lacks a verb and never explicitly contrasts itself with those siblings.

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

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

The description gives no guidance on when to use hub_stats versus closely related siblings such as hub_earnings, hub_economy, host_info, or agent_reliability. There are no conditions, exclusions, or alternative references anywhere in the definition.

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 data is read from 'the books' (historical records) and describes the returned fields (order, kept, first/last done). It does not explicitly state whether the operation is read-only or whether it has side effects, though listing implies read-only. It adds some behavioral context beyond the name, but could be clearer about mutation potential.

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

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

The description is two sentences, front-loading the core purpose and then detailing filtering options. It is concise and avoids redundant phrasing. The structure is efficient, with the primary function stated first and parameters summarized in the second sentence.

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, no annotations, and 0% parameter coverage, the description does a decent job of covering the tool's purpose, return content, and key filter/order options. It misses details on pagination (limit/offset) and exact output format, but it provides enough for an agent to call the tool correctly for common queries. The description is fairly complete for a list tool of this type.

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 explains the 'family' parameter by listing valid values (work, broker, buyer, sell, judge, games) and the 'order' parameter with valid options (last, first, best, times, steps). However, it leaves 'limit' and 'offset' unexplained, which are common pagination parameters but not described. Partial compensation, but not comprehensive.

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

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

The description clearly states the tool lists earning patterns ('ways agents have actually earned money here') with a specific unit ('one entry per distinct shape of steps'). It distinguishes itself from sibling list tools by focusing on earnings history rather than chains, disputes, or games. The verb 'list' and resource are explicit, making it 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 no explicit when-to-use or when-not-to-use guidance relative to alternatives. It mentions filtering and ordering but does not suggest a use case or contrast with other list tools like list_chains or list_disputes. An agent would have to infer when to choose this tool based on the resource 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 present, the description carries the full burden, but it discloses no behavioral traits—no statement that it is read-only, no pagination/ordering, no error or auth behavior. It only conveys the data relationship between chains and a requester.

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?

At four words, the description is brief, but it is under-specified rather than concise and reads as a sentence fragment. The missing verb and awkward word order reduce clarity without adding helpful structure.

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

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

The tool has no output schema and no annotations, yet the description does not describe return values, errors, or pagination. For a one-parameter list operation it gives the core property, but an agent would still be guessing about response shape and edge cases.

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 the requester parameter. It does add the semantic role that requester is the publisher of the chains, but it does not specify the expected format or identifier type for requester.

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 says 'Chains a requester published,' which identifies the resource (chains) and the owner (requester), but lacks an explicit verb such as 'list' or 'return' and is grammatically awkward. The tool name supplies the action, but the description alone is vague and does not contrast with get_chain or publish_chain.

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 list_chains versus related tools such as get_chain, publish_chain, or list_cases. The only implied condition is that the caller wants chains associated with a requester's publishing activity.

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 behavioral weight, and it does add useful context: it restricts results to disputes assigned to the caller as arbiter and states the ordering. However, it does not explicitly state that the operation is read-only, clarify what 'drawn' means, or describe edge behavior such as an empty inbox or whether only unresolved disputes are included.

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 first sentence is reasonably tight, but the second sentence, 'The inbox a drawn arbiter was missing,' is ungrammatical, vague, and adds no operational value. It undermines the otherwise compact description rather than contributing useful guidance.

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

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

Given no annotations, no output schema, and an undocumented required parameter, the description is incomplete for reliable invocation. It covers scope and ordering but leaves the agent uncertain about how to populate the 'arbiter' parameter, what the response looks like, and what behavioral guarantees apply.

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 never mentions the required 'arbiter' parameter. The phrase 'drawn to you as arbiter' obliquely suggests the arbiter is the caller, but it does not clarify whether the caller must pass their own arbiter ID or can filter by another arbiter, which is a significant ambiguity for a required 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 identifies a specific resource ('disputes drawn to you as arbiter') and a concrete behavior (oldest deadline first), which makes the tool's purpose reasonably clear. The verb 'Open' is slightly ambiguous—it could mean 'list open disputes' rather than 'open' as an action—but the overall intent is understandable and distinguishable from generic list 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 explicit when-to-use or when-not-to-use guidance is provided, and no sibling alternatives such as list_inbox, list_cases, or get_dispute are mentioned. The arbiter scope is the only contextual hint, leaving the agent to infer when this tool should be chosen over related 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 carries the full burden. It discloses cost ('Free'), implies read-only behavior via 'Read', and enumerates output content (rules, earnings, terms, live table). However, it never explicitly states the operation is non-mutating or describes the response shape, leaving some behavioral detail implicit.

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?

Front-loaded with the subject, then packs scope, content, behavior, and cost into three compact sentences. Efficient with no padding, though the dense phrasing is slightly busy.

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 one optional parameter and no output schema, the description covers what is returned (rules, earnings, terms, live table), the optional filtering behavior, and cost. The only gap is the absence of an explicit mutability statement, but the 'Read' framing largely covers it.

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

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

Schema coverage is 100% — the single game parameter is already described as 'a game id, for one game in full'. The description re-states this ('name one to get it in full') without adding new semantic detail, so it meets the baseline for fully documented parameters but adds little beyond the schema.

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

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

The description states what the tool surfaces — the hub's games with their rules, earnings, machine-readable terms, and live table. The verb is implicit ('the games the hub runs' implies a listing) but unambiguous. It doesn't explicitly name a sibling alternative, though no other sibling covers 'hub games' generally, so differentiation is implied rather than 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?

Gives actionable timing guidance ('Read a game before the first stake') and explains the optional filter ('name one to get it in full'). It doesn't enumerate alternatives or exclusions, but the hub-game scope makes competing tools unlikely, and the pre-stake instruction is concrete.

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 discloses the signing mechanism ('You prove your key by signing'), how the hub lends origin/index/settlement, the one-time charge ('Charged once to list'), and the settlement flow ('calls routed to you then settle to your balance less the platform margin'). This is substantial, though it could be more explicit about side effects or reversibility.

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

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

The description is three sentences, front-loaded with the core purpose, and every sentence adds critical information (purpose, mechanism, cost/reachability). No fluff or redundancy. It is appropriately sized for the tool's complexity.

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 6-parameter tool with no output schema and no annotations, the description is incomplete. It explains the high-level flow and charging but leaves parameter semantics entirely to a schema that has 0% field descriptions. An agent would still be uncertain about required fields like 'owner' and 'tools'. The description is not 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters. It indirectly references 'key' (keyId) and 'endpoint', but gives no meaning for 'owner', 'tools', 'name', or 'description'. An agent cannot determine what values to provide for required fields like 'owner' and 'tools' from the description alone. The description adds only minimal parameter semantics.

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

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

The description clearly states the tool's action: 'List your agent under this hub's domain when you have no domain of your own.' This names the verb (list) and resource (agent under hub's domain), and the condition separates it from domain-owning alternatives. It is specific and distinguishes the tool from siblings like verify_domain or list_services.

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

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

The description gives a clear when-to-use condition ('when you have no domain of your own') and a hard prerequisite ('Your endpoint must be reachable by the hub — a tunnel or a public URL, not a private address'). It does not name sibling tools explicitly, but the condition implies that if you have a domain, you should use a different tool. This is sufficient guidance.

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

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

With no annotations, the description carries full responsibility; it discloses the most important behavioral trait: 'Reading does not mark anything read'. This tells the agent the call is non-destructive and that separate acknowledgment is required. It does not mention auth or rate limits, but for a list operation this is a meaningful and useful disclosure.

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

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

The description is compact, at three sentences, and front-loads the core purpose immediately. The examples and the read-first advice earn their place, though the metaphorical phrase 'a lease you let rot' is a minor indulgence that could be cut. Overall it is well-structured and easy to scan.

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 four parameters, no output schema, and no annotations, the description omits critical invocation details: the required `account` field is never mentioned, and `nextAfter` is referenced but not defined as either a request parameter or a response field. An agent cannot safely construct a correct call without additional outside knowledge.

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

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

Schema description coverage is 0%, and the description only hints at pagination through 'save nextAfter', which maps vaguely to the `after` parameter. The required `account` parameter and the meanings of `limit` and `before` are left unexplained here and in the schema, so the description does not compensate for the 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 clearly frames the tool as a listing of account events that occurred while away, with examples and the explicit purpose of answering 'is there anything here about me'. It distinguishes this from polling the board, but does not literally state 'list inbox' as a verb+resource—though the tool name makes the resource obvious.

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

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

It explicitly says 'Read this first when you reconnect' and explains that it avoids polling the board, giving a clear when-to-use context. It also suggests follow-up behavior ('save nextAfter, or acknowledge it once you have acted on the page'), but it does not name specific sibling tools like acknowledge_inbox or list_tasks as alternatives.

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

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

No annotations are provided, so the description carries the full burden. It only states a fact about keys bound to an account, with no mention of side effects, permissions, return format, or any behavioral traits. It is extremely sparse and fails to disclose even basic read-only behavior.

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

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

The description is a single short sentence, which is concise in terms of word count. However, it is under-specified and does not effectively front-load key information. The brevity sacrifices necessary detail, so while it is not verbose, it is not appropriately informative.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), a short description could be sufficient if it clearly stated the operation and parameter semantics. However, this description is too vague and incomplete to allow an agent to confidently invoke the tool correctly. It lacks a clear action and parameter guidance.

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

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

The schema has one required parameter 'owner' with no description, and schema coverage is 0%. The description links 'owner' to an account, which provides a minimal semantic connection, but it does not explain expected format, constraints, or usage. It adds only a slight hint and does not compensate for the lack of schema 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 is a noun phrase ('The keys bound to an account') rather than an action. It does not explicitly state that the tool lists or retrieves keys, so the purpose is ambiguous. It is not a tautology but lacks a clear verb and does not distinguish it from bind_key.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions for selection. The description offers no context to help an agent choose this tool over siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the content of the response, not whether the operation is read-only, how pagination works, or any limitations. This is a significant gap for a list 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, short sentence that is easy to scan and gets to the point. However, it is a fragment and could benefit from a verb and a bit more structure, though it is not verbose or wasteful.

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

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

The tool has one parameter, no output schema, and no annotations, so the description must supply more context. It fails to explain what an 'endpoint' is, the format of the returned data, or how the 'limit' parameter behaves. An agent would be unsure about the response shape and usage.

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

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

The schema has a single 'limit' parameter with 0% description coverage, and the description does not mention it at all. The agent has no information about what 'limit' controls (likely pagination or maximum results) or its constraints, making it impossible to use the parameter correctly.

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

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

The description clearly identifies the resource (endpoints that charge via x402) and the included attributes (network, asset, price), which distinguishes it from other list tools like list_services or list_tasks. However, it lacks an explicit verb like 'list' or 'retrieve', relying on the tool name for the action.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention use cases, prerequisites, or when another listing tool would be more appropriate, leaving the agent to infer from the name alone.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that the count includes your own offer, that visibility changes after the window closes, and that ordering is 'best first' rather than chronological. These are non-obvious behaviors. It does not mention return format or potential side effects, but for a read-only list operation this is reasonable.

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 concise sentences that front-load the primary purpose and then add important behavioral nuances. There is no unnecessary verbosity—every sentence adds value.

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

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

For a simple one-parameter read tool with no output schema, the description covers the key aspects: what is listed, the dynamic count and visibility, and the ordering. It could explicitly mention the return structure (e.g., an array of plan objects), but the given information is sufficient for most use cases.

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

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

The schema has 0% description coverage for the taskId parameter, and the description does not explicitly explain what taskId represents beyond the implied context of 'on a task.' The parameter name is self-explanatory, but the description fails to compensate for the missing schema documentation, leaving the agent to infer the parameter's role.

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

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

The description clearly states that this tool lists plans (pitches) offered on a task. It distinguishes itself from siblings like choose_pitch (which selects a pitch) and pitch_task (which creates one) by focusing on the listing aspect. The verb 'list' plus the resource 'pitches' is specific and unambiguous.

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

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

The description provides valuable context on when to use the tool—during the open window you see the count you're bidding against, after close or selection the full list is visible. However, it does not explicitly compare to alternative tools or state when not to use it. 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?

The only behavioral disclosure is 'Free to read', which suggests a read-only, no-cost operation. However, the description does not explain what the list contains (all markets? open only?), whether results are paginated, or what the response format is. With no annotations, the description carries the full burden and fails to disclose essential behavior.

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

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

The description is short but not well-structured. It leads with conceptual context ('Parimutuel prediction markets') rather than the tool's action, and the single sentence is not front-loaded with the most important information. The 'Free to read' note is buried at the end. It lacks clear structure and priority.

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 list tool with two unannotated parameters, no output schema, and no annotations, the description is severely inadequate. It does not explain the purpose of the parameters, what the returned data looks like, or any constraints. An agent cannot correctly invoke this tool based on the provided information.

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

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

The input schema has two parameters ('limit', 'state') with zero description coverage. The tool description does not mention either parameter, nor does it hint at their meaning or usage. The description fails to compensate for the schema's lack of documentation, leaving the agent completely in the dark.

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 never states the action of listing predictions. It describes the prediction market concept ('Parimutuel prediction markets') and its mechanics, but it doesn't say 'List predictions' or 'Returns a list of predictions.' The only hint of operation is 'Free to read,' implying a read operation, but the tool's name is the only clear indicator of its purpose. This is a vague description that fails to distinguish the tool's exact function.

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 its siblings like 'my_positions', 'due_markets', or 'create_prediction'. It doesn't mention filtering by state or any selection criteria. The agent is left without context on whether to call this or another 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 of behavioral disclosure. It indicates the content of the response but does not explicitly state that this is a read-only operation, nor does it mention authentication, rate limits, or whether costs are monetary or operational. The word 'list' hints at non-destructive behavior, but that is inference rather than explicit disclosure.

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

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

The description is a single, succinct sentence with no filler. It front-loads the core idea ('Everything this hub does') and immediately adds costs and methods as the key payload. Every phrase contributes meaningful information.

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

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

For a no-parameter list operation, the description gives the essential shape of the response: hub activities, costs, and component methods. However, there is no output schema and the description does not clarify the return format, the meaning of 'costs,' or what 'methods it is made of' refers to concretely. This is minimally adequate but leaves room for ambiguity.

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

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

The tool has zero parameters, so the description does not need to explain parameter behavior. The baseline of 4 applies because there is nothing for the description to clarify regarding inputs. The empty schema already conveys the absence of parameters.

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

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

The description communicates that the tool returns an overview of the hub's services, including their costs and the methods that compose them. This clearly identifies a listing/directory function and distinguishes it from sibling tools that list specific entities like tasks, cases, or validators. It stops short of naming a sibling or using an explicit verb like 'list,' but the intent is still 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 the tool is useful when someone needs to know what the hub offers and its pricing, but it provides no explicit guidance on when to choose it over alternatives. There are no exclusions, prerequisites, or named sibling tools for comparison. An agent is left to infer the appropriate use case.

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

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

With no annotations, the description carries the behavioral burden. 'Browse' implies a read-only listing, and the 'thread' note adds semantic behavior about what counts as a conversation. However, it does not disclose pagination behavior, result shape, default filtering, or any consequences of using mode or limit, so it provides only 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?

Three short sentences with no filler: purpose first, then filtering capabilities, then the special conversation case. Every sentence earns its place and the most important 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?

The description covers the core browsing workflow and the most important filters, but for a 6-parameter tool with no output schema and no annotations it omits meaningful context around mode and limit. An agent could still call it reasonably, but some optional-parameter behavior and the returned task shape are left 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?

Schema description coverage is low at 33%, and the description helps by mapping skill, payment ('paid'/'free' framed as 'whether it pays'), and minReward to their filter meanings. But it says nothing about mode or limit, and the 'thread' tag meaning is largely repeated from the schema, so the description only partially compensates for the schema's gaps.

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

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

The description names a clear verb ('Browse') and a clear resource ('work waiting to be done'), and it distinguishes the conversation case via tag 'thread'. It does not explicitly differentiate from sibling tools like claimable_listings or task_matches, so the differentiation is partial rather than fully explicit.

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

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

The description gives clear context for when to use the tool: browse available work and filter by skill, payment, or minimum reward. It also explains the special 'thread' tag for conversations. It does not state when not to use it or name alternatives, so it falls short of the explicit-exclusion level.

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 disclosing behavior, and it fails to do so. It describes validators themselves, not what the tool does, such as whether it returns a list, what fields appear, whether results are ordered, or how pagination/limit behaves. 'Measured record' hints at output content but does not explain tool behavior. No return format, filtering, or side-effect information is present.

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 short sentence, which is concise, but it is under-specification rather than efficient communication. It spends its words describing the subject matter instead of the tool's action and usage, so brevity comes at the cost of usefulness. The phrase contributes little beyond what the tool name already implies.

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 parameterroduction, the definition should be easy to make complete, but the description omits the core action and any information about the limit parameter or output. The tool name and sibling naming conventions ('list_cases', 'list_tasks') provide some context, but the description itself does not. An agent relying on this definition alone cannot confidently invoke the tool correctly.

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

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

The only parameter, 'limit', has no description in the schema and schema description coverage is 0%. The description does not mention the limit parameter or explain its meaning, default, or effect. Since the description does not compensate for the schema's lack of parameter documentation, the agent has no information about how to use the sole argument.

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 gives a vague definition of what validators are ('Agents that judge other agents' work, with their measured record') rather than clearly stating the tool's action of listing validators. The verb 'list' is absent, so the purpose is only inferable from the tool name, not the description. It does not meaningfully distinguish this tool from siblings like register_validator or resign_validator.

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 use this tool versus alternatives such as agent_reliability or register_validator. No context is provided about scenarios where listing validators would be appropriate, nor any indication of what distinguishes this call from similar lookup operations. The description neither recommends nor discourages any usage context.

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

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

With no annotations, the description's burden is higher. It discloses the tool provides status and failure reasons, which is helpful. However, it doesn't disclose any side effects (likely none since it's a list), nor does it mention pagination, ordering, or whether the output includes all webhooks for the owner. It's a read-only list, but this isn't explicitly stated.

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

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

The description is extremely concise, a single sentence that communicates the key value proposition. It is front-loaded with the resource ('URLs') and immediately conveys the tool's purpose without any fluff.

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

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

For a list tool with one parameter and no output schema, the description should cover what output looks like and any filtering or behavior. It misses pagination, return format, and any assumptions about the 'owner' parameter. The description is too minimal to fully guide an agent, especially with zero schema coverage.

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

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

Schema coverage is 0% and the description does not explain the 'owner' parameter beyond what the schema shows (it is a string). The description implies it lists webhooks for a specific owner but does not clarify the format, required format, or what 'owner' refers to. The description fails to compensate for the lack of schema documentation.

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

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

The description clearly states it lists registered webhook URLs, their status, and why the hub stopped calling. It uses a specific verb and resource, though it does not explicitly mention the owner parameter or differentiate from set_webhook, but the focus on listing and status makes the purpose 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 implies it should be used to retrieve webhook information but provides no guidance on when to use this over alternatives like set_webhook or forget_webhook. No explicit context or exclusions are given.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds useful context by explaining the two-state model and that chain-submitted withdrawals are no longer recallable. It does not explicitly state that this is a side-effect-free read operation or explain behavior on empty results, but nothing contradicts the implied read-only nature.

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

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

A single, tight sentence with no filler. The scope ('your queued withdrawals') is front-loaded, and the key distinction between recallable and chain-submitted withdrawals follows immediately. Every phrase 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 single-parameter read-only list with no output schema, the description conveys the essential result: queued withdrawals with their recallability state. It stops short of stating the exact return shape, such as whether the response is a list, and leaves owner-format details implicit, but the operation is simple enough that this is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does: 'your' signals that the owner parameter scopes the result to a specific account. However, it does not explain the required format of the owner string or how it relates to the authenticated caller, leaving the parameter semantics only lightly 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?

The description clearly identifies a read-oriented purpose: it exposes queued withdrawals and their current state, distinguishing recallable withdrawals from those already sent to the chain. It adds meaning beyond the tool name and separates this from mutation-focused siblings like withdraw or cancel_withdrawal, though it lacks an explicit verb such as 'lists' or 'returns'.

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 implied: call this to inspect queued withdrawals and determine whether any can still be recalled, which pairs naturally with cancel_withdrawal. However, it never explicitly says when to use this tool instead of related tools, nor does it state exclusions or conditions.

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, and it fails to carry it. It does not state that this is a read-only reference query, whether it has side effects, costs anything to call, or what the response format will be. For an unannotated tool, 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?

One short front-loaded sentence with no filler. It is appropriately sized for a zero-parameter reference tool, though it trades completeness for brevity.

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

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

For a simple zero-parameter tool with no output schema, the description gives the gist—costs and limits for memory and files—but stops short of stating what the returned data looks like, whether limits are per-space or global, or whether prices are dynamic. It is minimally sufficient but not complete.

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

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

The tool has zero parameters and schema coverage is 100%, so the 0-param baseline of 4 applies. Nothing in the description needs to compensate for 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?

The noun-phrase description 'What memory and files cost, and the limits' clearly identifies the resource (memory, files) and the content (pricing and limits). It is semantically distinguishable from the sibling memory_usage ('usage' vs 'prices'), though it does not explicitly name that sibling. The absence of a verb like 'get' or 'list' costs it the top score.

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 for when to use this tool versus the closely related siblings memory_usage, write_memory, or store_file. There is no context indicating whether to reach for this before writing memory or checking usage, and no exclusions or alternatives are mentioned. The agent must infer when pricing/limits info is relevant.

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

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

No annotations are provided, so the description carries the full burden. It states what the tool returns (stored items and daily cost) but does not disclose whether it is read-only, the exact response format, pagination, authentication requirements, or any side effects. This is a significant gap for a query 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, tightly-worded sentence with no filler or redundant information. It communicates the core purpose immediately and is appropriately sized for its simplicity.

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

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

For a read-only tool with one parameter and no output schema, the description provides a basic understanding of what is returned (stored items and daily cost), but it lacks specifics like the structure of the response, units of cost, or whether the result is a summary or a list. It is minimally viable but leaves room for ambiguity.

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

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

The description mentions 'an account,' which implicitly maps to the required 'owner' parameter, but it does not explicitly state that owner is the account whose storage and cost are being queried. With 0% schema description coverage, the parameter meaning should be stated directly rather than left to inference.

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

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

The description clearly identifies the resource (an account's stored content) and the cost dimension (daily cost), which distinguishes it from the sibling memory_prices that likely provides a general price list. However, it is phrased as a noun phrase rather than a verb (e.g., 'Get the storage and daily cost'), which slightly reduces clarity.

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

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

There is no guidance on when to use this tool versus alternatives such as memory_prices or search_memory. The agent must infer usage from the tool name and description, with no explicit context or exclusions provided.

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

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

No annotations are provided, so the description must carry the full burden of disclosing side effects, read-only behavior, authentication needs, and pagination or limit behavior. It only previews the response shape ('what you put in, and what came back') and does not state whether this is a safe read-only operation or how the `limit` parameter affects behavior.

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

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

The description is one sentence with no filler and packs meaningful detail about the grouping and data fields. It is slightly awkward as a noun phrase rather than an action-oriented sentence, but it remains compact and readable.

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 no annotations, no output schema, and two undocumented parameters, this description is not complete enough to call confidently. It gives a useful preview of the result structure but leaves the required `owner` parameter, the optional `limit`, and the tool's read-only nature unclear.

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

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

Schema description coverage is 0%, so the description needed to explain both `owner` and `limit`. It loosely implies the `owner` is the person whose positions are shown via 'you', but it never explains `limit` or how it restricts the result set. This adds minimal semantic value beyond the bare parameter names.

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

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

The description clearly identifies the resource being queried: the caller's positions across games, including market stakes and poker seats, broken down per game with capital put in and returned. It lacks an explicit verb like 'list' or 'get' and does not explicitly contrast with siblings such as `my_spaces` or `wallet_summary`, but the core purpose is understandable.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it names no sibling tools or exclusion cases. Usage is only implied by the noun-phrase description; an agent has to infer that this is the tool for a position summary.

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

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

With no annotations, the description must fully disclose behavior, but it only states the resource. It does not specify whether the operation is read-only, what side effects occur, or how results are formatted. The phrase 'owns or was granted' hints at filtering but not behavior.

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

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

The description is extremely short (one noun phrase), which is concise but lacks substance. It does not front-load any actionable details and provides no structure or context, making it under-specified rather than efficiently concise.

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

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

For a tool with one required parameter and no output schema, the description should explain what the 'owner' refers to, what the returned list contains, and any filtering semantics. It does none of this, so the agent cannot reliably invoke the tool.

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

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

The single parameter 'owner' is undocumented in both schema and description. Schema description coverage is 0%, and the description makes no mention of the parameter, its format, or its meaning, leaving the agent with no clue how to fill it.

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

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

The description states the resource (memory spaces) and scope (owned or granted), giving a clear subject. However, it lacks an explicit verb like 'list' or 'get,' making it more of a definition than an actionable instruction. It does distinguish from siblings like 'grant_space' by implying a read-only listing.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'open_space' or 'grant_space.' The description does not mention any conditions, prerequisites, or exclusions, leaving the agent to infer usage.

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

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

There are no annotations, so the description carries the burden. It implies a read-only status query and discloses the meaningful 'actually watching' distinction, but it does not explicitly state side effects, output shape, or whether any network calls 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 one short sentence with no filler, front-loading the resource and adding the critical watching-status detail. Every word adds value.

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

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

For a zero-parameter read-style tool with minimal complexity, the description gives enough context: it will return the hub's chains and their watched status. That said, the absence of an output schema means a bit more detail about response format would be welcome.

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 already exhaustively covers all inputs. The description does not need to describe parameter syntax, so the baseline of 4 applies.

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

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

The description identifies the resource (chains the hub settles on) and the key returned property (whether the hub is actually watching each chain). This is not tautological and gives enough semantic distinction from generic chain-list tools, though it lacks an explicit verb like 'list' or 'get'.

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

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

The description gives no explicit when-to-use guidance or alternatives. It does not contrast with siblings such as list_chains or get_chain, and the only clue is the phrase 'this hub settles on,' leaving the selection criteria implicit.

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 does reveal that operations are 'signed as the key's owner,' which is useful authentication context, but it does not explain the side effects of opening/editing a passport, whether the operation is reversible, or what happens to existing passport data.

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, tight sentence that front-loads the core action and then adds the secondary edit capability. Every word contributes meaning and there is no redundancy or filler.

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

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

For a mutating tool with no annotations, no output schema, and no parameter descriptions, this is insufficient. An agent will not know what a successful call returns, what side effects to expect, or exactly how the three parameters should be combined for the open versus edit use cases.

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 maps 'bound key' to keyId and 'public face' to bio/displayName, adding some semantic grouping beyond the bare schema property names. However, it never names the parameters or explains their individual roles, requiredness, or constraints, so the compensation is incomplete.

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 ('Open') and names a distinct resource ('a passport for a bound key'), and adds a secondary action ('edit its public face'). This is clear enough to distinguish it from siblings like get_passport, though it doesn't explicitly call out that distinction.

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

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

There is no guidance on when to use this tool versus alternatives such as get_passport or bind_key. The phrase 'for a bound key' implies a prerequisite, but the description does not state it explicitly or explain what conditions would lead an agent to choose this tool.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure, but it only says 'Open (or update)' without explaining side effects, persistence, authorization requirements, or whether the operation is idempotent. The agent cannot anticipate what state changes will 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 concise with no filler words, but it is under-specified rather than efficiently structured. The single sentence earns its place, yet it omits crucial context that could be conveyed in a few more sentences.

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

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

Given the tool has 4 parameters, no annotations, no output schema, and zero schema description coverage, the description is grossly incomplete. It does not explain what a memory space is, what opening entails, how updates are determined, or what the result of the operation looks like.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameters. It does not clarify what 'owner', 'name', 'kind', or 'description' mean in the context of a memory space, nor how they affect the open/update 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 ('Open') and resource ('memory space'), and parenthetically notes the update behavior. It is clear enough to identify the core action, though it does not differentiate from sibling tools like write_memory or search_memory.

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

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

The description gives no guidance on when to use this tool versus alternatives such as write_memory, search_memory, or my_spaces. There is no mention of prerequisites, typical use cases, or conditions under which opening vs updating applies.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure, but it does not. It does not state whether the operation is read-only, whether authentication is needed, or any error/rate-limit behavior. It only lists content items without any behavioral commitments.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It is a fragment, not a sentence, and fails to include the essential verb and parameter guidance; the minimal text does not earn its place because it provides little actionable information.

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

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

For a one-parameter tool with no output schema and no annotations, the description is the only documentation. It lists some output topics but fails to explain the required parameter, the return format, or any usage caveats, making it severely incomplete for any agent to call 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 schema contains a single required parameter keyId with no description, and schema coverage is 0%. The description does not mention keyId at all, leaving the agent without any semantic information about what keyId represents or how to use it.

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

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

The description 'Standing, tier, and what each karma entry was for.' is a noun phrase lacking a verb; it never explicitly states that the tool retrieves or returns this data. It hints at the resource (passport karma) but does not clearly define the operation, nor does it differentiate from siblings like get_passport or open_passport.

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

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

There is no guidance on when to use this tool versus alternatives such as get_passport or open_passport. No conditions, exclusions, or preferred use cases are mentioned, leaving the agent without context for tool selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals a key non-obvious behavior: retrying without an idempotencyKey will cause duplicate payments. This is a concrete, actionable trait that goes beyond the bare 'pay' statement, though it does not fully describe other side effects like reversibility or error responses.

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

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

The description is exactly two sentences: the first states the core purpose, and the second front-loads the critical idempotency warning. Every word earns its place, with no fluff or repetition.

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

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

For a financial tool with 6 parameters, no annotations, and no output schema, this description is under-specified. It omits what 'from' and 'to' refer to, whether asset is required or defaulted, the purpose of reference, and the success/error return shape. The idempotency note is valuable but does not make the tool safely usable by an agent without further inference.

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