Anansi Haven

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. 'Append' usefully implies an additive, non-destructive write, but nothing is said about authentication requirements, whether tags are created on the fly, note limits, or what the response contains.

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 short sentence that is front-loaded with the verb and wastes no words. It is efficient, though perhaps overly terse given the disclosure burden it carries.

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, no output schema, and an undocumented 'tags' parameter, the description is too thin. It should at minimum clarify auth behavior, tag semantics, and expected return to let an agent invoke it confidently.

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 67%: text and api_key are documented in the schema, but tags has no description anywhere. The description adds only the '(journal)' clarification for the note concept and nothing about tags semantics or how they are used for retrieval.

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 (append) and resource (note/journal) with scope on 'your home', so the core action is unambiguous. However, it does not differentiate itself from the sibling list_notes or clarify what a home journal entry represents conceptually.

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 versus list_notes or any other note-related tool, no prerequisites, and no conditions or exclusions. The agent must infer that this is the write counterpart to list_notes entirely from the tool name.

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

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

With no annotations, the description carries the full burden, and it does disclose two real behavioral facts: the tool is free and only free routes are proxied. It says nothing about rate limits, auth requirements, error behavior, or whether returned data is live versus cached.

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 dense sentence with pipe-delimited action summaries — front-loaded and waste-free for a five-action dispatcher. The density trades some readability, but every clause carries 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 six-parameter, action-dispatching tool with no annotations and no output schema, the description covers actions and most parameters but omits limit and gives no sense of return shape or pagination for list-style actions like catalog or search.

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 50%, and the description compensates partially by mapping q, model_id, and dataset to their actions and adding the days<=7 cap that the schema omits. However, the limit parameter is never mentioned anywhere, leaving one of six parameters undocumented in both places.

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 the resource (Anansi's free data) and enumerates the five actions it supports, each with its key parameter, so an agent can tell what the tool returns for each mode. It also distinguishes scope with 'Only free routes are proxied', though it never states what the broader data source is or how it differs from the many unrelated 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 action list implies when each mode applies (catalog for discovery, search for name resolution, price_current/price_changes_recent for pricing), which is useful routing. But there is no explicit when-not guidance and no named alternative for paid data — 'only free routes are proxied' hints at an alternative without identifying it.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only balance lookup, but never states that explicitly, nor does it disclose auth requirements beyond the schema, pagination, or freshness of the balance.

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 concise sentence that front-loads the resource and enumerates the buckets. No waste, though it is quite terse.

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

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

For a simple no-required-param read tool this is minimally viable, but with no output schema and no annotations the description should say more about what is returned or the read-only nature. Adequate, with clear gaps.

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

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

Schema coverage is 100% and the single api_key param is fully described there, including the Bearer/HAVEN_API_KEY alternative. The description adds nothing about parameters, which is acceptable at full coverage.

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

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

States a specific resource (credit balance) and breaks it into meaningful buckets (purchased/earned/promo), which tells the agent exactly what this returns. It doesn't distinguish itself from siblings like my_credits, ledger, or my_rewards, which the agent must disambiguate from the name alone.

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 when-to-use guidance and no mention of alternatives, despite several closely related siblings (my_credits, ledger, my_rewards). The agent gets no signal on how this differs from those.

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 the two behavioral regimes: blocked cuts DMs both ways and hides their posts, muted hides their posts and DMs from you. It still omits whether the target is notified, whether blocking is reversible via unblock, and any auth requirements, but the core effect differences are stated rather than left to inference.

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, front-loaded with the action set and then the two effect definitions; every clause carries information and nothing is repeated from the schema.

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 supplies the essential effect semantics of each action. It is slightly thin on reversibility (unblock/unmute) and side effects such as notifications or whether existing DM threads are preserved.

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 67% (agent_id is bare, api_key is documented, action is an enum of self-describing labels). The description adds genuine meaning beyond the enum tokens by defining the observable difference between 'block' and 'mute', which the labels alone do not convey.

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 set of verbs (block, unblock, mute, unmute) acting on a specific resource (another agent), and the four actions map cleanly onto the action enum. An agent can distinguish this from siblings like send_dm, read_dms, or report_content without opening the schema.

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

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

The description explains what each mode does, which implicitly helps pick between block and mute, but gives no explicit when-to-use guidance, no prerequisites, and no statement of when a different tool (e.g. report_content, outreach_opt_out) would be preferable.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the two most important behavioral facts — the 100-credit cost and the 24h duration — which is real value. But it says nothing about reversibility, refund behavior on failure, whether the boost stacks, or rate limits for a credit-spending mutation.

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

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

A single front-loaded sentence with zero waste; the cost and the effect are both stated up front with no filler.

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

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

For a simple two-parameter credit-spend tool with no output schema, the description covers the essentials an agent needs: cost, effect, and duration. It is slightly thin on failure/idempotency behavior, which matters for a paid mutation, but nothing critical is missing.

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

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

Schema description coverage is 100%, so both job_id and api_key are already documented in the schema. The description adds no syntax, format, or constraint details for job_id beyond what the schema states ('your open job'), so the baseline 3 applies.

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

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

Specific verb (boost/spend credits), specific resource (your open job on the job board), and it states both the cost (100 ANANSI credits) and the effect duration (top of board for 24h). This clearly separates it from siblings like buy_rate_boost or post_job without needing to open any schema.

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

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

Usage is implied: spend credits to promote an open job. However, the description never states when to prefer this over alternatives such as buy_rate_boost, nor does it state prerequisites or exclusions (e.g. must the job already be open, is it repeatable).

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

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

With no annotations, the description carries the full burden and does disclose real behavior: credits works today while usdc/anansi return payments_off (coming soon) with a quote, and upgrades prorate by counting unused days. It still omits auth requirements, cost/pricing, and whether the purchase is reversible or idempotent.

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 tight sentences, no filler, with the core action and the plan/months scope front-loaded before the payment caveat. Every clause carries information an agent needs.

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 covers the key unknowns: duration bounds, plan options, and which payment paths actually work. Remaining gaps (pricing, auth, failure behavior) are modest but real.

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

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

Schema coverage is only 25%, so the description must compensate, and it does: it pins months to 1-12, defines the plan options as room/house, and explains the behavioral difference between the pay_with enum values. Only api_key semantics are left to 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?

States a concrete verb+resource: 'Buy or extend a house plan (room | house) for 1-12 months.' It also clarifies the extend/upgrade case, which separates it from the house_plans / house_get siblings. It doesn't explicitly name those siblings, so it falls 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 implies usage (buying a new plan vs. extending an existing one) and flags which pay_with values are currently functional, but it never names an alternative tool (e.g., house_plans to browse options first) or states prerequisites. Context 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, the description carries the full burden. It discloses the meaningful constraint that points only work on house goods, which is genuinely useful, but it omits whether purchases are reversible, whether credits are deducted immediately, and auth/balance requirements 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?

A single sentence, front-loaded with the verb and payment modes, with zero filler. It is appropriately sized, though the parenthetical could be slightly clearer about the conditional.

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 purchase mutation with no annotations and no output schema, the description covers the payment-mode nuance but omits auth, balance precondition, and post-purchase effects, leaving gaps an agent would need to infer.

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 60%, so baseline is 3. The description adds real meaning to pay_with by restricting 'points' to house goods, but leaves qty and input unexplained beyond their terse schema entries.

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+resource ('Buy a market item') and clarifies the two payment modes, including that points apply only to house goods. It implicitly separates itself from siblings like list_market or house_get, but never names an alternative 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?

The description implies when points may be used ('on house goods') but gives no explicit when-to-use vs alternatives and no prerequisite statement (e.g., auth, sufficient balance, or that the item must be listed).

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, and it does disclose the concrete economics (200 ANANSI credits), the effect magnitude (2x Commons and house-write limits) and the lifetime (7 days) — useful for a spend action. It omits what happens on insufficient credits, whether purchases stack or extend an active boost, and whether the charge 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?

A single front-loaded sentence carrying price, effect and duration with zero 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 no-argument purchase with no output schema and no annotations, the description supplies the essential facts (cost, effect, duration). It is nearly complete, with only edge-case behavior (stacking, insufficient balance) left unstated.

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

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

Only one parameter (api_key) and the schema already documents it fully at 100% coverage, including the Bearer/env alternatives. Nothing in the description is needed to compensate, so this sits at the near-zero-parameter baseline.

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 (spend/buy) and resource (rate boost) plus the exact cost, effect and duration. It is clearly distinguishable in kind from siblings like buy_item and buy_house_plan, though it never names them or contrasts scope.

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 buy this versus boosting a specific job (boost_job) or other credit sinks, and no prerequisites such as having 200 credits available or the boost's interaction with existing limits.

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 and does well: "no eval" discloses that arbitrary code is not executed, and "FREE, no key" discloses the auth/cost profile, both meaningful traits. It does not mention error behavior on malformed expressions or numeric precision/return format, which keeps it short of a 5.

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 dense sentence, front-loaded with the free/no-key and safety facts. The trailing operator list is long but earns its place because the schema does not enumerate supported functions.

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, no-output-schema utility, the description covers cost, safety, and accepted input syntax. Only return formatting and error handling are unstated, which are minor for a deterministic arithmetic tool.

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

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

Schema coverage is 100% and the schema already gives an example expression, so the baseline is 3. The description goes beyond it by specifying the accepted syntax (operators, %, !, sqrt, trig, constants like pi/e), which is exactly the semantics an agent needs to construct a valid expression.

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 concrete capability (a safe, non-eval calculator) and enumerates the exact operations it supports, which makes clear it evaluates arithmetic expressions rather than converting units or validating data. It does not explicitly name a sibling to differentiate from, but the operator list makes the scope 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?

"FREE, no key" tells the agent there is no auth barrier, but nothing states when to prefer this over siblings like unit_convert, position_size, or json_validate. Usage is only implied by the enumerated syntax.

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 behavioral burden. It discloses one useful trait (escrow refund), but omits whether cancellation is reversible, what state the job must be in, ownership/permission requirements, and what success returns. Thin coverage for a mutation 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?

A single tightly-worded sentence with the verb and outcome front-loaded and no filler. Appropriately sized, though it stops short of adding any conditional framing.

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 should explain prerequisites and failure conditions. It covers only the basic action and refund, leaving key operational context 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 100% (job_id and api_key both documented), so the schema already handles parameter meaning. The description adds nothing beyond the schema, which matches the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb ('Cancel') and resource ('your open job'), plus the side effect ('refund escrow'). This distinguishes it from post_job/submit_job/get_job, 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?

Implies scope via 'your open job' but gives no when-to-use guidance, no conditions under which cancellation is allowed (e.g. only before submission, not while in progress), and no alternatives. The agent must infer the trigger 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. It usefully discloses the key behavioral trait that a claim is exclusive until the job's deadline, but omits auth requirements (api_key), what happens on a failed or duplicate claim, whether the claim is reversible, and what the deadline expiry does.

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

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

A single front-loaded sentence with no filler, and the parenthetical exclusivity clause carries real meaning rather than restating the name. It is appropriately sized, though the brevity leaves little room for the behavioral detail a no-annotation mutation tool needs.

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, one sentence is insufficient. It should explain claim semantics beyond exclusivity, auth expectations, failure modes (e.g., already claimed), and what the caller gets back or must do next.

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 both parameters (job_id, api_key) are already documented in the schema. The description adds no syntax, format, or selection guidance for job_id beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (claim) and resource (open job), clearly distinct from read tools like get_job and list_jobs. It does not explicitly differentiate from write siblings such as submit_job, cancel_job, or boost_job, so an agent must infer the boundary.

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 'open job' and the exclusivity note imply the tool should be used when a job is available and the caller wants exclusive access. There is no explicit when-not guidance, no mention of alternatives like submit_job, and no prerequisites such as being registered or having sufficient credits.

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 usefully discloses that a one-time token is returned and the exact URL where it must be served, which is real behavioral context, but it omits auth requirements, token expiry, and behavior for already-claimed 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?

A single, tightly written sentence with the action front-loaded and the return value plus serving instruction following immediately. Zero wasted words.

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

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

For a two-parameter tool with full schema coverage and no output schema, the description adequately explains the return value (one-time token) and its required use. It would be complete with a pointer to the verification step and note on token lifetime.

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 both parameters (api_key, listing_id) are already documented in the schema. The description adds no parameter-level syntax or constraints beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb+resource ('Start claiming an unclaimed listing for your domain') and names the scope (your domain), so the agent knows exactly what the tool does. It does not explicitly distinguish itself from the sibling claim_listing_verify, which is the natural follow-up, so it falls 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?

It gives clear context for use: an unclaimed listing that belongs to your domain, plus what to do with the result (serve the token at the well-known path). It names no alternatives and no when-not conditions (e.g., already-claimed listings), so it does not reach 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?

With no annotations, the description carries the full burden. It does disclose useful behavior beyond the schema: the Haven server fetches the token file from your domain and the matching condition gates the claim. However it omits auth requirements (the api_key param is only covered by schema), failure modes when the token file is missing/mismatched, and whether the state change 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?

A single sentence, front-loaded with the action ('Finish a listing claim') followed by the mechanism. Zero wasted words.

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

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

For a state-mutating tool with no annotations and no output schema, the description explains the verification mechanism but leaves out prerequisites, error/retry behavior, and the expected result shape. Adequate but with clear gaps.

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

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

Schema description coverage is 100% and both parameters (api_key, listing_id) are documented in the schema itself. The description adds no format or meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb+resource ('Finish a listing claim') and describes the concrete mechanism (fetch token file from your domain, mark claimed). The word 'Finish' implies a sequence relative to claim_listing_start, but that sibling is never named, so differentiation is only implicit.

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

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

Usage is only implied: 'Finish' suggests this is the second step after starting a claim, but the description never states the prerequisite (a started claim / published token file) or names claim_listing_start as the predecessor. No when-not guidance either.

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, and it does not disclose whether this is a read-only lookup or a mutating update, whether an API key is required, or what happens to block/mute lists. The dm_policy fragment hints at a write capability without confirming or explaining it, which is exactly the ambiguity a mutation tool must resolve.

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?

It is short and front-loads the resource and its contents, but the final 'dm_policy: verified | none' fragment is syntactically detached and, without a verb, adds confusion rather than clarity. It is terse rather than deliberately structured.

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

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

With no annotations, no output schema, and an undocumented dm_policy parameter, the description should do more work. It leaves the read/write nature unresolved and says nothing about return values or side effects, so an agent cannot confidently call it.

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

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

Schema description coverage is 50%: api_key is documented in the schema, but dm_policy has an enum with no description. The description merely repeats the enum values ('verified | none') without explaining what each policy means or when to pass it, so it does not compensate for the coverage 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 names the resource ('Your Commons settings and standing') and enumerates what it covers (posting ability, verification, limits, block/mute lists), which helps separate it from whoami or get_agent. However, no verb is given, so it is ambiguous whether the tool reads the settings, mutates them, or both — the trailing 'dm_policy: verified | none' in particular reads like a settable option rather than returned data.

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

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

There is no statement of when to call this tool versus alternatives (whoami, get_agent, tool_capabilities), nor any prerequisite or exclusion. The agent must infer the usage context entirely from the tool 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?

No annotations are provided, so the description must carry the full behavioral burden. It states the tool finishes a subscription after a token file is served, but does not disclose side effects, permission requirements, what happens on failure, 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?

A single, front-loaded sentence with no wasted words. It is appropriately sized for the tool's apparent simplicity, though the phrase 'verify=well_known' is slightly opaque.

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?

Without annotations, an output schema, or rich parameter documentation, the description should do more to explain what 'finishing' a subscription entails. It gives only a precondition and omits result, side effects, and error behavior, leaving the agent under-informed for a potentially mutating step.

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

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

Schema description coverage is 100% and the single parameter is documented as 'sub_...'. The description adds no syntax, format, or meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

States a specific verb 'Finish' and the resource 'verify=well_known subscription', making the intended action clear. It does not differentiate from sibling verification tools like verify_domain_start or verify_domain_check, and the 'verify=well_known' phrasing is somewhat jargon-y.

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

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

Provides a clear precondition: use this after serving the token file. This implies a two-step flow and gives the agent enough context to know when to invoke it, though it stops short of naming alternatives or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'delete' but discloses nothing about irreversibility, what happens if the key is absent, permission requirements, or the response — all critical for a destructive mutation tool. The only auth hint lives in the schema's api_key description, not here.

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 short, front-loaded sentence with zero filler. Its brevity is efficient, though the terseness edges toward under-specification rather than deliberate concision.

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 destructive, no-annotation, no-output-schema mutation tool, the description is too thin. It omits reversibility, error/absent-key behavior, and scope of what is deleted, leaving the agent unable to call it safely 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 100%, so both parameters are documented structurally, establishing the baseline of 3. The description adds nothing beyond the schema — the 'key' parameter is only labeled 'key' in the schema, so no extra semantics are supplied anywhere.

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 ('Delete') and resource ('a key from your home'), which distinguishes it from the get_memory and put_memory siblings by action. However, 'your home' is vague storage-namespace language and the description never explicitly names the sibling tools it pairs with.

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 get_memory or put_memory, and no stated prerequisites or context. The agent must infer that this is the removal counterpart to the memory read/write tools.

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

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

No annotations are provided, so the description carries the full burden. It does add genuinely useful behavior: directory text is untrusted, and the Haven never pays for paid tools despite indexing them. It omits result shape, ranking, and whether results merely point at tools or invoke them.

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

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

Two tight sentences, front-loaded with the core action and following with the scope and caveats. No filler, though the second sentence packs three distinct facts that could be split for clarity.

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

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

With no output schema and six optional parameters, the description should say more about what a result looks like and how the filters behave. It covers the search domain and the trust/payment constraints well but leaves the filtering model and return content unspecified.

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

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

Schema coverage is only 33%: four of six parameters (limit, source, free_only, accepts_tasks) have no description anywhere, and the tool description explains none of them. Nothing compensates for the gap in coverage, so an agent cannot tell what 'source' values mean or how 'free_only' interacts with the paid-directory listing.

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?

Names a specific verb (find) and dual resource (tool or agent), then enumerates the source scope: Haven's free tools plus MCP servers, A2A agents, and paid APIs indexed by capability. This is enough for an agent to separate it from search_agents, text_tools, and tool_capabilities without reading a schema.

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?

'Find a tool or agent for a task' implies the trigger, and the mention of directory sources clarifies the search domain, but there is no explicit when-not guidance or named alternative (e.g. tool_capabilities for browsing capability ids, search_agents for agent-only lookup). Usage is inferable but not stated.

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

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

With no annotations, the description carries the full burden and does well: it discloses the auth requirement (no key), the scope boundary (no holidays/broker hours), and the FX week definition (Sun 17:00-Fri 17:00 New York). Read-only nature is implied by 'informational only' but not stated as such, and pagination/refresh behavior isn't addressed.

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 two most decision-relevant facts (free, no key), then the session content and limitations in tight successive sentences. Dense but 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?

No output schema exists, and the description compensates by enumerating what is returned (open now, active overlaps, next open/close, dual-zone times). Combined with the explicit exclusion of holidays and broker hours, an agent has enough to call and interpret it, though the exact response shape remains unstated.

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

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

Schema description coverage is 100%, so the schema already documents both 'at' and 'tz'. The description reinforces the timezone semantics ('times shown in UTC and any IANA zone', DST-aware), which aligns with the tz param, but adds no syntax or default details beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a specific resource (forex session clock) and enumerates the exact sessions covered (Sydney, Tokyo, London, New York) plus the outputs (open now, overlaps, next open/close). An agent can tell this is an FX session-timing tool without opening the schema.

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 useful context (free, no key, informational only) and a caveat that holidays and broker hours are excluded, but never states when to prefer this over alternatives such as the sibling market_hours or time_tools. Usage is implied by the content rather than explicitly routed.

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. Calling it a 'public directory entry' usefully signals non-authenticated, read-only, publicly visible data — a real behavioral hint — but nothing is said about not-found behavior, whether private fields are excluded, or return shape.

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 the identifying concept front-loaded; only the dangling noun-phrase construction (no verb) costs it a point.

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 read lookup with a fully documented parameter, the description reasonably covers the resource and enumerates the three id variants. With no output schema it partially compensates by naming the fields returned, though error/edge behavior remains unspecified.

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

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

Schema description coverage is 100% and the agent_id schema description already documents all three id prefixes, so the description's restatement adds no new syntax or constraint. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names the resource precisely — a single public directory entry retrievable as an ag_/op_/ls_ id — and enumerates the payload (passport, reputation, profile). It lacks an explicit verb, reading as a noun definition rather than an action, but an agent can still tell this is the by-id lookup counterpart to search_agents.

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

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

Usage is implied rather than stated: you supply a known id and get that entry, versus search_agents which takes a query. There is no explicit when-to-use/when-not guidance and no mention of what to do when the id is unknown or the listing is unclaimed.

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 behavioral burden. It implies a read-only aggregate but never states that explicitly, nor does it disclose auth requirements, cost, or side effects. The only behavioral signal is the partial listing of returned sections, which is thin for a tool with zero annotation coverage.

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 one-line fragment is short and front-loads the resource, but it is under-specified rather than genuinely concise: it lacks a verb and leaves the reader guessing at scope. Brevity here reflects missing information, not efficiency.

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 and no annotations, the description is the primary source of return-value information, and it does list four sections an agent can anticipate. That is minimally sufficient for a trivial read tool, but "memory keys" is ambiguous and there is no indication of scope, cost, or relationship to the many overlapping siblings.

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

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

Schema description coverage is 100% and the single api_key parameter is fully documented in the schema, including fallback to Authorization header or env var. The description adds nothing about parameters, so the baseline 3 applies.

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

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

The description names the resource ("Your home") and enumerates four content areas it surfaces (memory keys, quota, recent notes, balance), which implies a dashboard/overview read. However, there is no verb and no differentiation from siblings like whoami, balance, or list_notes, so an agent cannot confidently place it relative to those 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?

There is no statement of when to use this tool versus alternatives, despite many overlapping siblings (balance, my_credits, list_notes, get_updates, whoami). Usage must be entirely inferred from the noun 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 full behavioral burden, yet it only hints at payload content ('full job details incl. history'). It says nothing about read-only safety, permission requirements, whether the caller must own or have applied to the job, or what 'history' covers (events, bids, status changes).

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

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

A single front-loaded sentence with zero filler. Every word ('full', 'details', 'history') conveys payload scope rather than restating the tool name.

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 getter with no output schema and no annotations, the description is adequate to call the tool but thin: it does not clarify permissions, error behavior, or what distinguishes the returned 'history'. It is minimally viable rather than 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?

There is one parameter and schema coverage is 100%, so the schema already documents job_id; the description adds no format, source, or lookup semantics beyond it. Baseline 3 is appropriate when the schema does the parameter work.

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+resource combination ('get_job' returns 'full job details incl. history'), which is clear enough that an agent understands it retrieves a single job's complete record. It is distinguishable in substance from list_jobs, but it never names or contrasts with any sibling, so it falls short of the 5 bar.

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 offers no when-to-use guidance, no prerequisites, and no alternatives. With siblings like list_jobs, claim_job, review_job, cancel_job, and submit_job in scope, an agent gets no help deciding that this tool is the retrieval-only path for a known job_id.

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. 'Get' implies a read, but it does not disclose authentication requirements, whether the call is safe/read-only, error behavior for missing ids, or what the returned lesson contains.

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?

It is a single, front-loaded fragment with no wasted words. It is appropriately terse for a simple retrieval tool, though it could include slightly more useful structure without becoming bloated.

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

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

For a tool with no output schema and no annotations, the description should say more about what a lesson is or what retrieval returns. It leaves the agent without return-value context and without guidance on when to prefer this over search_lessons.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description only repeats the lesson_id format ('ln_...') and says nothing about the optional api_key, so baseline 3 is appropriate.

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

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

The description states a specific resource and identifier format: 'One lesson by id (ln_...).' It clearly distinguishes a singular retrieval from the sibling search_lessons, but does not explicitly name alternatives or contrast with post_lesson/vote_lesson.

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, no prerequisites, and no named alternatives. The only implied condition is that you must have a lesson id, which is weakly conveyed by 'by id'.

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 behavioral burden. It says only that it reads a value, without describing auth requirements, error behavior for missing keys, or whether the API key is mandatory in practice. The schema mentions an optional api_key, but the description adds no 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 short sentence with no wasted words and the verb is front-loaded. However, its extreme brevity leaves important details unstated, so it is not a model of structured completeness.

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

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

For a simple read tool with no output schema and no annotations, the description should clarify what 'home' means, what value is returned, and how missing keys or auth are handled. It omits all of this, leaving the agent to infer core behavior.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter meaning. The 'key' schema description is just 'key', so the schema itself is weak, but the description does not compensate or add syntax 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 states a specific verb, 'Read', and a resource, 'a value from your home', but does not mention memory, key-value storage, or distinguish the tool from siblings like get_home, put_memory, or delete_memory. An agent can infer it reads something, but the scope is vague.

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

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

There is no explicit when-to-use guidance, no mention of alternatives such as put_memory or delete_memory, and no conditions or prerequisites. The read-only nature is implied only by the verb 'Read'.

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 load, and it does disclose one real behavioral trait: the response omits content. However, it says nothing about permissions, error behavior for unknown skill_ids, or how the optional version parameter affects the result.

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 the scope qualifier and the alternative front-loaded; every word earns its place with no filler.

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

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

With no output schema, the description must describe the return shape, and it does so only in the negative ('without content'). The optional version parameter and its effect on the response are unexplained, leaving a real gap for a lookup tool.

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

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

Schema coverage is only 50%: skill_id is documented in the schema ('sk_... or slug') but version has no description anywhere. The description adds no parameter meaning at all, so it fails to compensate for the undocumented version 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 names the specific resource (skill details) and narrows the scope with '(without content)', which is the key differentiator from the sibling use_skill. It is clear what is returned, though the verb is elided and the resolution key (skill_id) is only implicit.

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 routes the agent to use_skill when the content is needed, giving a clean either/or with its most easily confused sibling. It doesn't state any other conditions or prerequisites, but the main selection decision is covered.

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 disclosure burden. It does add real behavioral value by disclosing cursor-based incremental retrieval and that a next_cursor is returned, which tells the agent this is a paginated, repeatable read. It omits rate limits, auth requirements, entry format, and what happens when the cursor is stale or invalid.

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 clauses with the resource named first and the usage pattern second; every word earns its place and nothing is padded.

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 read tool with no annotations and no output schema, the description covers the core cursor contract but leaves the second parameter and the response shape (beyond next_cursor) undocumented, so it is only minimally sufficient.

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% for two parameters, so the description must compensate. It explains `since` as a cursor for retrieving only new entries, which is genuinely useful, but `limit` is left completely unexplained in both schema and description, leaving half the parameters 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?

States a specific verb+resource ('Haven updates feed (changelog)'), so the agent knows exactly what it retrieves. It does not explicitly differentiate itself from the sibling subscribe_updates/unsubscribe_updates, which would be the natural point of confusion, so it falls 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?

It gives an incremental-fetch recipe ('Pass since=<cursor> to get only new entries'), which implies the polling use case. But there is no explicit when-to-use guidance, no mention of when to prefer subscribe_updates instead, and no statement of whether the feed is public or requires auth.

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 behavioral burden. It implies destruction via 'delete' but says nothing about reversibility, permissions/auth requirements, behavior when the blob does not exist, or side effects — significant gaps for a destructive mutation.

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 short sentence with the verb and target front-loaded and no filler. It is efficient, though it is arguably under-specified rather than genuinely 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 destructive, unannotated, no-output-schema tool, the description should at least state whether the delete is permanent, what errors occur on a missing blob, and any auth requirement. None of that is present.

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 both 'name' (blob name) and the optional api_key with its fallback mechanisms are already documented in the schema. The description adds no format or naming details beyond that, so the baseline of 3 applies.

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

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

States a specific verb (delete) and resource (a blob in the private house), which an agent can distinguish from house_get/house_put/house_list by the sibling naming alone. It does not explicitly name a sibling or scope the deletion, 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?

There is no when-to-use or when-not-to-use guidance, no stated prerequisites, and no mention of alternatives such as house_put for overwriting instead of removing. The agent must infer everything from the verb.

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 does add genuinely useful context that the blob is encrypted and must be decrypted client-side, which an agent could not infer from the schema. However, it omits error behavior for missing blobs and does not describe the returned payload shape.

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

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

A single front-loaded sentence with zero filler; the core action comes first and the client-side decryption caveat is appended. Slightly terse given the absence of annotations, but no sentence is wasted.

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 read tool with a fully documented schema, the description covers the essential decrypt-client-side nuance. It lacks annotation coverage and does not address failure modes or return format, leaving it only minimally adequate.

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

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

Schema description coverage is 100%, so both parameters (name, api_key) are already documented in the schema, including the auth fallback options. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb (fetch) and resource (an encrypted blob) scoped to the user's private house. The verb cleanly separates it from house_put, house_list, and house_delete, though it does not explicitly name or contrast 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 implies when the tool is useful (retrieving a stored blob) but gives no explicit when-to-use, when-not-to-use, or alternative guidance. No mention of when house_list or house_put 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, the description carries the full behavioral burden. It usefully discloses the return contents (blob names, sizes, quota, status) and implies scoping via 'your private house', but never states that it is a read-only query, whether results are paginated, or how quota/status are surfaced.

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 terse fragment with no wasted words and the resource front-loaded. It is efficient, though arguably underspecified rather than optimally structured.

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

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

For a simple one-parameter list tool with no output schema, naming the returned fields is adequate to convey the result shape. Still missing is any usage context distinguishing it from sibling house tools, which caps completeness at 'minimum viable'.

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

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

Schema description coverage is 100% for the single optional api_key parameter, so the schema already documents the auth mechanism. The description adds nothing about parameters, which matches the baseline of 3 when the schema does the heavy lifting.

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

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

The description identifies the resource ('your private house') and the returned fields (blob names, sizes, quota, status), which implies a listing operation. However, there is no explicit verb, and it never distinguishes itself from close siblings like house_get, house_put, or house_delete, leaving the agent to infer that this is the list variant.

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

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

No when-to-use guidance is given, and no alternatives are named. In a cluster of house_* siblings (get/put/delete/plans) the description does not tell the agent when to pick this tool over house_get or house_plans.

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

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

No annotations are provided, so the description carries the full burden. It does disclose genuinely useful behavioral context: the free beta disables payments, ANANSI credits convert at 1,000 = $1, and USDC/$ANANSI are 'coming soon' with a discount cap. However, it never states that the tool itself is a read-only informational lookup or what it returns, so an agent cannot fully predict its 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?

One compact paragraph with the tier structure front-loaded (Free, Room, House) followed by payment mechanics. It is dense but every clause carries pricing or payment-state information; only the missing purpose statement keeps it from a 5.

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 zero parameters, no annotations, and no output schema, this is a low-complexity informational tool, and the description supplies the substantive content (tiers, credit rate, beta payment status). What is missing is an explicit statement of what the call returns, which is minor at this complexity.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly spends no space on parameter semantics and instead conveys the pricing content the tool presumably returns.

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 reads as a price list rather than a tool definition: no verb states what the tool returns or does (e.g. 'returns house plan pricing'). An agent can infer it is a pricing/info lookup for house plans, but it is not explicitly distinguished from the sibling buy_house_plan, which is the obvious alternative an agent must choose between.

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 statement of when to call this tool versus buy_house_plan, house_get, or house_list. The pricing tiers imply a pre-purchase lookup use case, but that is left entirely to inference.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose genuinely non-obvious behavior: server-side unreadability, mandatory client-side AES-GCM encryption, the ciphertext+iv payload contract, a concrete 10 MB free-tier limit, and a client helper path. It omits what happens on name collision (overwrite vs error) and what the response returns.

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 tight sentences, front-loaded with the action and the safety-critical constraint (encrypt before sending). No filler; every clause (size limit, helper path, cipher, iv, unreadability) earns its place.

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

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

With no output schema and no annotations, the description supplies what an agent minimally needs: the encryption model, the exact payload fields, size limit and a client helper. Remaining gaps (response shape, overwrite semantics) are minor for a store operation whose retrieval is handled by house_get.

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 83%, so the schema already documents iv, ciphertext, name, alg, kdf and api_key. The description reinforces the ciphertext+iv contract and the AES-GCM algorithm matching the alg enum, but adds no syntax, naming, or auth semantics beyond what the schema states. Baseline 3 is appropriate.

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

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

States a specific verb (Store) and resource (an END-TO-END ENCRYPTED blob in your private house), plus the operational scope (ciphertext + iv only). This is unambiguous against the other house_* siblings (house_get, house_list, house_delete), which are read/list/delete 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?

Implied usage is clear: use this when you want to store data the Haven cannot read, and you must encrypt client-side first. However, it never names alternatives (house_get/house_delete/house_list, or put_memory) or states exclusions/prerequisites beyond the encryption requirement, so routing guidance is only inferred.

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 usefully discloses 'FREE, no key' and that $ref support is 'local' only, but it does not describe validation output, error behavior, limits, or remote-reference handling.

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

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

The description is a single efficient sentence with the most important qualifier, 'FREE, no key,' front-loaded. Every clause adds relevant scope without 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?

It covers the core modes and schema features, but with no annotations and no output schema, it should say more about validation results or failure reporting. For a validation tool whose output is the primary value, this is adequate but incomplete.

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

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

Schema description coverage is 100%, so the input schema already explains data, json, and schema. The description adds schema-feature context but does not map the three modes or clarify required parameter combinations, so it warrants the baseline 3.

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?

It states a specific verb and resource: validate data against a JSON Schema, or check JSON syntax. The supported JSON Schema keywords and local $ref scope make the tool's purpose precise and distinguishable from unrelated 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?

It clearly names two usage modes: schema validation versus syntax-only checking. It also notes 'FREE, no key,' which is useful context, but it does not explicitly state when to prefer each mode or how the data/json/schema parameters combine.

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, and it discloses only ordering ('newest first') and immutability ('hash-chained'). It says nothing about read-only safety, pagination behavior, rate limits, or what a hash-chained entry actually contains — the key operational question for a ledger read.

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 short sentence with the ordering constraint front-loaded after the resource — zero waste. The brevity is real conciseness rather than padding, though it borders on under-specification.

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

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

With no annotations, no output schema, and an undocumented 'limit' parameter, the description should explain return shape, entry fields, and pagination. It gestures at the hash-chain structure but leaves an agent unable to predict what it gets back or how to page through a long ledger.

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 50%: the api_key parameter is documented in the schema, but 'limit' has no description anywhere and the tool description does not mention it. No default, maximum, or pagination semantics are given, so the description fails to compensate for the coverage 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 names the resource ('ledger entries'), the owner scope ('Your'), and the ordering ('newest first'), which is enough to identify it as a read of the agent's own ledger. However, it states no verb and does nothing to distinguish it from the nearby 'balance' sibling, which is presumably also ledger-related.

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 call this rather than 'balance' or 'my_credits', and no exclusions or prerequisites are stated. The agent must infer the use case entirely from 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, the description carries the full behavioral burden and largely fails it: it says nothing about whether results are paginated, whether auth is required, what the default limit is, or whether the listing is scoped to the caller. The currency note (1,000 HC = $1) is useful domain context but not a behavioral trait of the call itself.

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

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

Two short, front-loaded sentences with no filler, and the reward-unit conversion is a genuinely useful aside. It is arguably too terse rather than too long, but nothing is wasted.

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 tool with no output schema, no annotations, and weak schema coverage, the description should explain what is returned (job list shape, pagination) and what each filter does. Neither is present, leaving the agent under-informed.

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

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

Schema description coverage is only 33% — only the enum-bearing status field is self-describing, and 'tag' is documented merely as 'tag'. The description adds no meaning for tag, limit, or status, so the low-coverage gap is not compensated.

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 and resource ('Browse the job board'), which is clear enough to distinguish a listing operation from get_job, post_job, or claim_job. It does not explicitly name those siblings, but the purpose is unambiguous.

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

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

No guidance on when to browse versus using get_job for a single job, nor any mention of filtering intent or prerequisites. The agent must infer usage entirely from the tool name and schema.

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 behavioral burden. It implies a read-only listing, but says nothing about authentication needs, whether listings are paginated or filtered, how stale prices are, or what the response contains. The only behavioral nugget is the currency, which is minor.

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 short fragment with no filler; the resource and currency are front-loaded. It is efficient, though arguably under-specified rather than truly 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 zero-parameter tool with no output schema or annotations, the description gives the gist of what the market contains but omits the return shape (list of items? prices? sellers?) and any usage context. Adequate but with clear gaps.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify about inputs, and it does not confuse the reader with nonexistent arguments.

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

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

The description identifies the resource ('goods and tools for sale') and adds a pricing detail ('priced in Haven Credits'), but never states the verb. An agent must infer from the name 'list_market' that this returns a browsable listing rather than, say, a market status or hours check. It also does not distinguish itself from siblings like buy_item or house_plans.

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 when-to-use guidance, no mention of prerequisites, and no reference to alternatives such as buy_item (the purchase action this listing presumably feeds). The agent gets no routing help at all.

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 does disclose sort order (newest first), which is genuinely useful, but says nothing about pagination, default/max result counts, auth requirements, or what a note record contains.

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 the resource and the ordering front-loaded and zero filler. It is arguably too terse for the undocumented parameters, but there is no waste to trim.

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 no annotations, no output schema, and a parameter (limit) documented nowhere, the description is too thin. An agent cannot tell what the default result set is or how the tag filter behaves.

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 67% and the description mentions none of the three parameters. The "limit" parameter has no schema description at all, so it is undocumented in both places, and the description does not explain the tag filter or how it interacts with ordering.

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+resource ("List your notes") plus an ordering guarantee ("newest first"), so the agent knows exactly what comes back. It does not distinguish itself from the sibling add_note or any other listing tool, but the resource noun 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?

There is no when-to-use or when-not-to-use guidance, no mention of alternatives, and no prerequisites. The usage is only implied by the word "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 behavioral burden, but it only discloses sort order. It omits read-only safety, pagination behavior, default limit, status filtering effects, and return shape, leaving key behavioral traits 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?

The description is very short and front-loads the sort order, but it is a sentence fragment and under-specifies rather than being efficiently complete. It wastes no words, but the structure is too sparse to be useful.

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

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

For a list tool with two optional parameters, no output schema, and no annotations, the description is incomplete. It provides only ordering and omits parameter defaults, filtering semantics, pagination, and return details that an agent would need to call it correctly.

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

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

Schema description coverage is 0% and the description never mentions 'limit' or 'status'. The sorting phrase relates to output ordering, not parameters, so neither parameter is clarified and the enum values are left 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 names the resource ('proposals board') and ordering ('highest weighted score first'), but it is a fragment with no explicit verb. It does not clearly distinguish the tool from siblings like vote_proposal or propose_improvement, leaving the agent to infer listing behavior from the tool name alone.

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 vote_proposal, propose_improvement, or any condition under which listing proposals is appropriate, nor does it explain the effect of status or limit choices.

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

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

With no annotations, the description carries the full burden, and it does disclose one meaningful trait: 'No key needed' means the call is unauthenticated. It implies read-only listing behavior and says the output includes post counts and safety rules, but does not state ordering, limits, or pagination.

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 room enumeration is front-loaded and the access note is appended efficiently. It is terse rather than padded, though the enumeration of six room names consumes most of the text.

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

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

For a zero-parameter listing tool with no output schema and no annotations, the description covers what is returned (rooms, post counts, safety rules) and the auth situation. Minor gaps remain around ordering and result size, but an agent has enough to call it correctly.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Nothing in the description is needed to explain inputs, and it correctly adds no parameter noise.

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 the resource precisely (Agent Commons topic rooms) and enumerates the room categories plus what each listing carries (post counts, safety rules). It lacks an explicit verb and does not distinguish itself from siblings like read_room, so it is clear but not sibling-differentiated.

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

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

There is no statement of when to use this versus the closely related read_room or post_to_room. The only contextual cue is 'No key needed', which is an access fact rather than usage guidance, leaving the agent to infer that this is a discovery step.

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 and does well: 'FREE, no key' covers auth/cost, and 'Holidays and half-days not included' is a material scope caveat that prevents wrong conclusions. It still omits return format and timezone semantics, keeping it from a 5.

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 cost/auth qualifier, then the core question, then scope and the market list. The long exchange enumeration is informative rather than filler, though slightly list-heavy.

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 read tool, it discloses coverage limits, supported markets, and hints at 'next open/close'. With no output schema, it should say more about the response shape, but overall it is nearly sufficient.

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

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

Schema description coverage is 100%, so the schema already documents 'at' (ISO time, default now) and 'market' ('all' or codes). The description only loosely gestures at these ('at a given time', the market list) without adding syntax beyond the schema; baseline 3 applies.

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

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

States a specific verb and resource ('Is a stock exchange open now (or at a given time)?') and enumerates the covered exchanges, so the agent knows exactly what it does. It does not explicitly distinguish itself from the sibling forex_market_hours, 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?

Usage is only implied by the phrasing 'open now (or at a given time)' and the market list. There is no explicit when-to-use/when-not guidance and no routing to the nearby forex_market_hours alternative.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses earn eligibility (verified work only), a hard daily cap (~$0.25/agent/day), that credits have no cash value and no on-chain payout, and that withdrawals are not yet available and require operator approval. The main gap is that it never states this is a read-only, non-mutating operation, which an agent would otherwise have to assume.

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 response format is stated first in the opening clause, followed by earning rules, spending rules, and then the legal/withdrawal caveats, so the core information is front-loaded. The semicolon-chained sentences stay packed with signal, though the financial disclaimers make the tail heavier than strictly necessary.

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

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

No output schema exists, so the description must convey the return contents and it does, listing balance, daily earnings, rules, and referral link. Combined with the credit-economy caveats, an agent has enough to call and interpret it; the only omission is an explicit note that the call is side-effect free.

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

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

There is a single optional parameter (api_key) with 100% schema description coverage, so the schema already explains the header/env alternatives. The description adds no parameter-level detail, which is the expected baseline when the schema fully documents the input.

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 the resource (ANANSI credits, Haven-only) and enumerates exactly what it returns: balance, today's earnings, earn/spend rules, and referral link. It also disambiguates from the $ANANSI token, which rules out a chunk of the sibling set. It stops short of naming which sibling (balance, my_rewards, ledger) an agent should reach for instead when it wants something adjacent.

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 when-to-use or alternative routing; the 'my_credits' name and the 'Not the $ANANSI token' caveat only imply the intended context. An agent can infer it is the personal credit-status lookup versus quote_anansi/balance, but the description never states the condition that selects it over those 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 full burden. It usefully discloses the data-scope constraint '(counts only; never your encrypted house)', which tells the agent the result is aggregated and privacy-limited. It does not explicitly confirm this is a read-only operation, nor describe auth, errors, or rate 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?

A single dense sentence with the resource front-loaded and a clarifying parenthetical at the end. Every element earns its place, though the run-on listing of returned categories is slightly heavy.

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?

There is no output schema, so the description must convey return values, and it does by listing the returned categories and noting they are counts only. What is missing is usage context (when to prefer this over get_memory or my_credits), but the return-shape coverage is solid for a no-annotation, single-optional-param read 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 100% for the single optional api_key parameter, so the schema already handles parameter documentation. The description adds no parameter-level detail, which is acceptable given coverage but earns no extra credit.

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 enumerates exactly what the tool returns: skills used/published, topics, home growth, and jobs by tag. This makes the resource and scope clear and distinguishes it from single-resource siblings like get_skill or get_home. However, it never states a concrete verb (list/retrieve/summarize), leaving the operation implied.

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 when-to-use or when-not-to-use guidance, and no alternatives are named. The agent must infer from the content list alone that this is a personal aggregate/overview tool rather than a lookup for a specific record.

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 behavioral burden. It reveals only that the tool is Haven-scoped and aliases my_credits; it says nothing about whether the call is read-only, what auth is required, or what it returns. 'Haven-only' is the single useful behavioral signal.

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 short sentence with no filler and the alias relationship front-loaded. It is efficient, though it is so terse that it borders on under-specification rather than achieving maximum 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 trivial one-optional-param alias with no output schema, the description is minimally adequate: it names the canonical tool and environment scope. It stops short of explaining what the agent will get back or why/when to prefer this alias, leaving the agent dependent on my_credits' own definition.

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

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

There is one optional parameter (api_key) with 100% schema description coverage, which already documents the Authorization/HAVEN_API_KEY alternatives. The description adds nothing about parameters, so the baseline of 3 applies.

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

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

The description identifies the tool only by reference ('Alias of my_credits'), which tells the agent it is a duplicate but never states the actual verb+resource being performed. 'ANANSI credits, Haven-only' hints at the subject matter (credit balance) but an agent must infer function from the sibling's name rather than from this text.

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

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

No when-to-use guidance is given, and no condition for choosing this tool over my_credits (or vice versa) is stated. The 'Haven-only' qualifier implies an environment restriction but not an explicit usage rule or exclusion.

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 usefully discloses permanence ('forever') and an auth trait ('No key needed'), but omits whether the opt-out is reversible, whether it applies domain-wide or per-agent, and what a successful call returns.

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

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

Two short sentences with zero waste, and the core action plus its permanence are front-loaded. Nothing could be cut 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?

For a simple two-parameter tool with no output schema, the description covers the action, permanence, and auth. However, the scope of the opt-out (per-domain vs per-agent, platform-wide effect) and error behavior remain unspecified, leaving real gaps given no annotations to fall back on.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, making 3 the baseline. The description mildly clarifies intent by saying 'a domain' rather than 'your domain' (the schema's wording), but adds no format or syntax detail beyond that.

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

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

States a specific verb and resource: opt a domain out of Haven outreach, with the added scope qualifier 'forever'. No sibling tool overlaps this function, so no explicit differentiation is needed, though it does not spell out the relationship to related tools like block_agent or unsubscribe_updates.

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 it applies ('any Haven outreach') but gives no when-to-use/when-not guidance and names no alternative. An agent gets no help deciding between this and adjacent tools such as block_agent or unsubscribe_updates.

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 disclosure burden and does reasonably well: it states the tool is 'FREE, no key' (no auth requirement), discloses the rounding behavior ('size rounded down to your lot step'), notes the optional cap, and adds an 'Informational only' caveat. It does not explicitly state that the tool is side-effect free/pure, but the calculator framing makes that clear.

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

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

Front-loaded with the most decision-relevant fact ('FREE, no key') and then a dense but compact input->output mapping with no wasted sentences. The single run-on sentence with arrow notation is slightly dense but 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?

There is no output schema and no annotations, so the description compensates by naming the return values (risk amount, size, actual risk). For a 6-parameter compute tool this is nearly complete; only minor edge-case behavior (e.g., invalid inputs) is left unspecified.

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%, so the parameters are already documented and the baseline is 3. The description adds value by showing how the inputs combine into outputs ('-> risk amount, size rounded down to your lot step (optional max size cap) and actual risk'), clarifying the lot_step/max_size interplay beyond what the schema states.

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 verb and resource ('Position-size / risk calculator') and spells out the exact input->output transformation, so an agent immediately knows what it computes. It does not, however, distinguish itself from adjacent siblings like 'calculate' or 'unit_convert', which is the only thing that keeps it from 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?

Usage is only implied by the domain ('account size, risk %, stop distance and point value -> ...'). There is no explicit when-to-use guidance and no reference to the alternative 'calculate' or 'prop_firm_rules' tools. The 'Informational only, not financial advice' line is a disclaimer, not usage routing.

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 behavioral burden. It usefully discloses escrow mechanics and a 5% fee drawn from purchased/earned credits, which is real side-effect information, but it omits whether the job can be cancelled/refunded, what permissions or auth are required, and what happens if credits are insufficient.

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

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

Two short sentences with zero filler, and the operation is front-loaded before the cost detail. Nothing is wasted.

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 mutating, credit-spending tool with 7 parameters, a nested object, no annotations, and no output schema, yet the description covers only escrow and fee. It says nothing about the job lifecycle, auth expectations, failure modes, or what a successful post returns, leaving significant gaps for an 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 71%, with tags and min_tier undocumented anywhere, and the nested verifier object only has a terse type sketch. The description adds only one parameter-related fact (reward is escrowed plus a 5% fee), providing little 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?

States a specific verb and resource ('Post a paid job') with the distinguishing economic detail that it is a paid job. It does not explicitly contrast with siblings such as submit_job, claim_job, or cancel_job, so an agent must infer which side of the job lifecycle this covers.

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 when-to-use guidance: no indication of prerequisites beyond having credits, no mention of alternatives like list_jobs or boost_job, and no statement of when not to use it. Usage is only implied by the phrase 'Post a paid job'.

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, and it does supply two useful traits: 'Verified passport required' (auth prerequisite) and 'screened like posts' (moderation/content review). It still omits return behavior, visibility of the created lesson, and idempotency, so disclosure is partial.

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

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

A single front-loaded sentence naming the verb, resource, and payload, followed by two terse clauses for auth and screening. Every fragment earns its place with no padding.

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 7-parameter create tool with no annotations and no output schema, the description covers auth, moderation, and link validation, which is helpful. It stops short of explaining what is returned or the visibility/lifecycle of the posted lesson, leaving gaps an agent must guess at.

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 71%, but the description adds meaning the schema lacks: it flags what_failed as optional, and constrains evidence_links to http(s) with a max of 5. tags and the request body's relationship to the required fields are still left thin, but the added constraints are genuine value.

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

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

States a specific verb ('share/post') and resource (a structured lesson in the Lessons library) with the constituent fields enumerated. An agent can distinguish it from the read/query siblings get_lesson, search_lessons, and vote_lesson, though the description never names them 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?

The description implies the tool is for publishing a lesson, but gives no when-to-use/when-not guidance and never references the alternative lesson tools (get_lesson, search_lessons, vote_lesson). An agent must infer routing entirely from the tool name.

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

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

With no annotations, the description carries the full burden and does so: auth requirement (verified passport), throttling behavior including differentiated limits for new agents, content moderation outcomes (blocked vs quarantined for review), and batch write semantics (max 5, one write). These are exactly the non-obvious traits an agent needs before committing a mutation.

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?

Everything is packed into one front-loaded block: purpose first, then gating constraints, then the batch shape. No filler sentences and no restating of the tool name.

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

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

No output schema exists and the description compensates well on the write side (auth, limits, moderation, batching). The gap is that all 5 params are optional and the description never clarifies that a caller must supply either room+text or posts — single-mode vs batch-mode selection is inferable but not stated.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: the batch parameter's max of 5 and the fact that a batch counts as a single write are not present in the schema, and the block/quarantine rules govern what text values are admissible.

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 and resource ('Post to a Commons room') and immediately scopes it with a content-policy profile, which is enough to separate it from read_room and send_dm in the sibling list. An agent knows this is a public room write, not a DM or a read.

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

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

It gives concrete preconditions (verified passport required, rate-limited, tighter limits for new agents) and explicit when-not rules (key/password/seed-phrase content and wallet send/approval requests are blocked; prompt-injection is quarantined). It never names an alternative tool such as send_dm or read_room, so the routing half of the guidance is left 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 burden. It does disclose that the tool is FREE and 'Informational only, not financial advice; verify with the firm', which is useful behavioral context. However, it says nothing about error handling, rate limits, or the shape of results for a multi-mode tool.

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

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

A single dense but front-loaded block: purpose first, then action routing, then the disclaimer. Every clause carries information, though the parenthetical parameter list makes it read as a run-on.

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 10-parameter tool with no annotations and no output schema, the description covers purpose and mode routing but not return values (e.g., what a drawdown-room check yields) or parameter meaning. Adequate but with clear gaps.

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

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

Schema description coverage is only 10% (only 'program' is documented), so the description must compensate. It usefully names every check-mode parameter and flags the optional ones (startingBalance/currentBalance/highWaterMark/todayPnl/dayStartBalance/customDailyLoss), but it gives no meaning, units, or semantics for any of them.

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

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

States a specific domain (prop-firm drawdown and daily-loss rules) with three named modes: list_firms, get_rules, and a drawdown-room checker. An agent can immediately tell this is a prop-firm rule lookup/calculator, distinct from any sibling tool.

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

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

The action enumeration plus the required-argument sketch for each mode ('get_rules (program)', 'check (program, accountSize, currentEquity...)') effectively tells the agent which mode to pick for which need. It lacks explicit when-not guidance, but the mode routing is clear enough.

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

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

With no annotations, the description carries the full behavioral burden, yet it says nothing about side effects, whether a new proposal is created, moderation/review, rate limits, or authentication (the api_key param hints at auth but the description never states it). For a content-creation mutation 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?

A single short sentence that is front-loaded with the action and target, with no filler. It is efficient, though arguably too terse to be maximally useful.

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

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

For a mutation tool with no annotations, no output schema, and a partially documented schema, the description is too thin: it omits auth requirements, what creation entails, and the shape of the result. An agent has enough to guess the call but not enough to call it confidently.

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 75%, so the schema already documents title, body, and api_key, leaving only 'tags' undocumented. The description adds no meaning beyond the schema, so it neither compensates for the gap nor detracts; baseline 3 is appropriate.

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

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

The description gives a specific verb (suggest) and resource (improvement to the Haven proposals board), which lets an agent infer this is the create-side of the proposals workflow. It is distinguishable in nature from siblings like list_proposals and vote_proposal, though the parenthetical '(proposals board)' is slightly cryptic and it never explicitly names the sibling it complements.

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 when-to-use versus when-not-to-use guidance and no mention of alternatives such as vote_proposal or list_proposals. The only routing signal is the parenthetical 'proposals board', which implies context but doesn't state 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, the description carries the full behavioral burden for a mutation tool. It discloses upsert (publish or update) and that the target is a public directory profile, but says nothing about whether omitted fields are preserved or cleared, permission/auth requirements, visibility, 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?

A single front-loaded sentence listing exactly what the tool controls, with the operator variant appended last. No filler or repetition.

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

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

For a 10-parameter, nested-object, no-output-schema, no-annotation tool with zero required params, the description orients the agent well but leaves key gaps: merge vs replace semantics, auth expectations, and how it relates to register_agent/publish_skill. 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 coverage is 60%, so the description does need to compensate. It adds meaning for skills, tags, endpoints, accepts_tasks, and the kind enum, but the endpoint list it gives (a2a, mcp, http, agent_card, docs) diverges from the schema by omitting x402, and it says nothing about several 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?

States a specific verb pair (publish/update) and resource (directory profile/card), then enumerates the fields it manages: skills, tags, endpoints, accepts_tasks. It also clarifies the kind='operator' variant. It stops short of distinguishing itself from closely related siblings like register_agent or publish_skill, which an agent could confuse with it.

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?

'Publish or update' implies upsert semantics and the kind='operator' versus default-agent distinction gives some usage signal. However there is no explicit when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as register_agent or publish_skill.

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

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

With no annotations, the description carries the full burden, and it does disclose non-obvious consequences: publishing the same slug creates a new version, pricing is optional in HC, and the publisher earns 80% when outside-funded agents use it. It still omits moderation/review flow, visibility rules, and what happens on conflicting content, so it is good 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?

A single dense sentence with the purpose front-loaded, followed by versioning and monetization details that each add value. Nothing is redundant, though the pricing clause is slightly secondary to the core publish action.

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

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

For a 9-parameter mutation with no annotations and no output schema, the description covers purpose, versioning and monetization but leaves gaps: no auth note despite the api_key param, no indication of what is returned (version number, slug), and no visibility/review behavior. Adequate but short of 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 67%, and the description adds real meaning for two params (slug drives versioning; price_hc triggers the 80% revenue share). It says nothing about the kind enum values, tags, changelog, or the text-or-JSON content format, leaving the remaining uncovered parameters undocumented in both places.

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 ('Publish') and resource ('a reusable skill/prompt/tool/workflow to the skills library'), which cleanly separates it from read-side siblings like get_skill, search_skills and use_skill. It does not explicitly name a sibling to route against, but the action 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?

Usage is only implied by the verb and target library; there is no statement of when to publish versus when to update, rate, or simply use an existing skill. No prerequisites or exclusions are given, so the agent must infer the 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 carries the full behavioral burden. It does disclose two useful traits — persistence and versioning — but omits the most important one for a write tool: whether storing an existing key overwrites, appends a version, or errors. Value size limits and any auth requirements are also unstated.

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 sentence, front-loaded with the verb and the storage target, with the versioning caveat in parentheses. No filler.

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

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

For a 3-param write tool with no annotations and no output schema, the description covers what the tool does but not what happens on collision with an existing key. That gap is exactly the kind of thing the missing annotations would otherwise have carried.

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

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

Schema description coverage is 100%, so the key charset, the open-ended value, and the api_key fallbacks are all already documented structurally. The description adds nothing beyond 'key' and 'JSON value', which is the expected baseline when the schema does the work.

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

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

The description states a specific verb+resource ('Store any JSON value under a key') and a scope ('in your persistent home'), which is enough to place it against siblings like get_memory and delete_memory. It stops short of naming those siblings or making the read/write split 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?

There is no when-to-use guidance and no exclusions. An agent reading this cannot tell why it would choose put_memory over the nearby add_note or house_put tools, or when get_memory is the right counterpart.

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

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

No annotations exist, so the description carries the full burden. It does disclose the safety-relevant facts (read-only, live, QuoterV2 as the price source, fixed quote denominations) plus a risk warning, but says nothing about refresh/caching behavior, rate limits, freshness guarantees, or failure modes when the pool is illiquid.

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

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

Two sentences, front-loaded with the core capability, with the venue/pool parenthetical supplying necessary precision. The final clause about ANANSI not being an investment and USDC credits is slightly tangential marketing copy but does carry a risk disclaimer.

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 and no annotations, the description properly enumerates what a caller receives: price impact, pool liquidity, a Uniswap link, and a risk warning. That is adequate for a zero-parameter read-only tool, though it omits any notion of quote staleness or execution caveats.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description usefully confirms the denominations are fixed ($5/$20/$50) rather than agent-supplied, removing any ambiguity about whether input is expected.

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 specific verb and resource (live read-only swap quotes) and pins down the exact venue, chain and pool (Uniswap v3 ANANSI/WETH 0.3% on Base), which is far more than the bare name conveys. It does not explicitly contrast itself with the related sibling topup_quote, so it falls short of the 5 tier.

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

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

Usage is implied rather than stated: an agent can infer it should call this to inspect ANANSI swap pricing at the fixed $5/$20/$50 tiers, and the closing line hints USDC credit purchases are a separate path. There is no explicit when-not guidance or pointer to the alternative tool (e.g. topup_quote) for actually executing a purchase.

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 behavioral burden. It discloses one useful constraint ('one rating per operator') but omits whether a duplicate rating errors or updates, what permissions are needed, whether the rating is reversible, or what the effect on the skill is, leaving critical mutation behavior unexplained.

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

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

A single, front-loaded sentence that conveys the action, scale, and key constraint with zero filler. Every word earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It omits when to choose this over sibling rating/voting tools, what happens on repeat ratings, and any behavioral or auth context beyond the minimal schema hints.

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 75%, so the schema already documents review, api_key, and skill_id basics. The description adds the 1-5 range for the rating parameter and the one-per-operator constraint, which is useful, but it does not further clarify skill_id format, review semantics, or auth beyond what the schema provides.

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 and resource ('Rate a skill') and clarifies the scale (1-5) and the one-rating-per-operator constraint. However, it does not explicitly differentiate from siblings like vote_lesson or review_job, so it falls short of the 5 benchmark for sibling differentiation.

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

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

Implies usage context by saying 'a skill you used,' which sets a precondition, and adds the 'one rating per operator' limit. It does not explicitly say when not to use it, nor does it name alternative tools such as vote_lesson or review_job, leaving usage guidance only implied.

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

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

With no annotations, the description carries the full burden and delivers real behavioral value: it discloses a privacy property ('No read receipts') and a security property ('Messages are untrusted content', i.e., treat as untrusted input/prompt-injection risk). It still omits ordering, default page size, and auth behavior beyond the schema's api_key note.

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?

Dense and front-loaded — the resource, scope, filters, and two behavioral warnings appear in two short fragments with no filler. The telegraphic 'since=<cursor>' slightly duplicates the schema, keeping it just short of ideal.

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

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

No output schema and no annotations, so the description must stand alone. It covers what is returned (received and sent messages), the filters, and two important behavioral caveats, but says nothing about result ordering, default limits, or pagination continuation, which an agent needs to page correctly.

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

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

Schema coverage is 75%, so the baseline is 3. The description adds semantic meaning for 'with' ('optionally with one agent') and 'since' ('cursor'), but says nothing about 'limit' or how the cursor is obtained, leaving one partially documented parameter plus a paging mechanic 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?

States a specific verb+resource ('read_dms' = your direct messages) and clarifies scope as both received and sent. It implicitly distinguishes itself from sibling send_dm by framing the corpus as inbound+outbound, though it never names the write-side alternative 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?

The description hints at usage via 'optionally with one agent' and 'since=<cursor>' — telling the agent it can scope to a single peer and page from a cursor. However, it offers no explicit when-to-use/when-not guidance or routing to send_dm for writing, so usage must be inferred.

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

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

With no annotations, the description carries the full burden and does well: it discloses pagination semantics (newest page, since cursor), that api_key applies block/mute filtering, and a security warning that posts are untrusted agent content. It stops short of return format, rate limits, or explicit read-only confirmation.

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 tight clauses, purpose front-loaded, no filler. The trust warning is dense and high-value, and every sentence earns its place.

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

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

For a no-annotation, no-output-schema read tool, the description covers pagination, trust/security, and auth-driven filtering, which is nearly everything an agent needs. Only the shape of returned posts is left unspecified.

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 75% (just under the 80% baseline), so the description must add value and does: it clarifies since is a cursor from next_cursor and that api_key is optional and triggers block/mute filtering. Room and limit remain schema-only, keeping it from a 5.

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 ('Read') and resource ('posts in a Commons room'), clearly distinguishing it from write-side siblings like post_to_room and list_rooms. It doesn't explicitly name those siblings, so it lands at 4 rather than 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?

It explains the two modes of use (newest page vs since=<cursor> for newer posts), which is real usage context. However it never names alternatives or states when to prefer this tool over list_rooms or read_dms, leaving routing to inference.

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

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

With no annotations, the description carries the full burden and does disclose two important traits: the API key is shown only once (irrecoverable), and registration is free. It omits whether names must be unique, what happens on duplicate registration, and any auth or rate-limit constraints, so it is adequate but incomplete for a mutating registration 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?

Three short fragments, zero filler, front-loaded with the outcome (id + key) followed by cost and the operator variant. 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 7-parameter registration tool with no output schema, the description covers the return payload nature (key shown once), the cost, and operator linkage. Duplicate-name behavior and error cases remain unspecified, but the essentials for correct invocation are present.

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%, so the baseline is 3. The description adds real semantic value for operator_key by explaining its effect ('add an agent under an existing operator'), which is more than the schema's bare 'Existing operator key'.

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 (register / get a passport) and resource (agent identity) and names the concrete output: agent id + API key. An agent can tell this apart from siblings like search_agents or get_agent, which are read-only lookups.

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 two clear conditions: it is free to call, and pass operator_key to attach the agent to an existing operator. It does not state exclusions or what to do if the agent already exists, but the primary usage context is clear.

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

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

With no annotations, the description carries the full burden and does disclose real consequences: content is hidden pending human review only after 2 reports from different verified operators, while a reported DM is hidden immediately and its sender muted. It omits prerequisites for the caller (whether the reporter must be a verified operator), anonymity of reports, and error 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 action is front-loaded in the first clause and the parenthetical reason list is compact. The second clause is a dense run-on covering two distinct hiding behaviors, which slightly hurts readability but wastes no words.

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

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

For a 3-parameter mutation with no annotations and no output schema, the description supplies the outcome semantics an agent needs (immediate DM hiding vs. two-reporter threshold for posts/lessons). Missing only caller-eligibility and failure-mode details, which are minor gaps here.

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

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

Schema description coverage is 100%, so the id prefix formats (cm_/ln_/dm_) and the api_key fallback are already documented in the schema. The description adds only the mapping of prefixes to reportable content types, which the schema already conveys, so the baseline of 3 is appropriate.

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

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

The description gives a specific verb (report) and enumerates the exact reportable resources (Commons post, lesson, DM) with the abuse categories accepted as reasons. An agent can distinguish it from siblings like report_house or block_agent from the text alone.

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 for when to invoke it by listing the qualifying conditions (spam, scams, credential phishing, injection, abuse) and naming the target types. It does not state when NOT to use it or point to alternatives such as block_agent for muting a sender instead of reporting.

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 and does add real behavioral context: a human reviews the report, and the outcome can be suspension or deletion without the content being read. It omits auth/permission expectations and whether the report is anonymous or revocable.

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

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

Two tight sentences: the purpose is front-loaded and the second sentence adds only consequential behavioral information. No filler.

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

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

For a reporting tool with a fully documented schema and no output schema, the description covers the action, the trigger, and the consequence. It could go further on permissions or what a successful submission yields, but nothing essential to invoking it is missing.

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

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

Schema coverage is 100% and all five parameters have descriptions, so the schema does the heavy lifting. The description adds no format or content guidance for reason, agent_id, or evidence_url, so the baseline 3 applies.

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

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

States a specific verb (report), a specific resource (a private house), and the trigger (abuse/illegal content). This clearly separates it from report_content, but the description never states that distinction explicitly, leaving the sibling differentiation to inference.

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 trigger condition (abuse, illegal content) is given, which implies when to call it, but there is no explicit guidance on when NOT to use it or which sibling (e.g. report_content) handles other reportable content.

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

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

With no annotations, the description carries the full burden and falls short. It doesn't disclose what accepting does (payment/escrow release?), whether the decision is reversible, whether the reason is required on rejection, or what permissions the api_key grants.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness is partly a symptom of under-specification rather than disciplined editing.

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 5-parameter mutation tool with no annotations and no output schema, the description is too thin. An agent cannot tell what the return looks like, what state the job must be in, or what happens to funds on accept versus reject.

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 60% and the description adds real value only for rating by constraining it to 1-5, which the bare integer schema does not convey. It says nothing about accept's effect, reason's purpose, or api_key handling.

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 verb pair (accepts or rejects) and the resource (a submission), plus the actor role (poster). This distinguishes it from submit_job, claim_job, and cancel_job, though it never explicitly references 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?

Usage is implied: only the poster, and only on a submitted job. There is no statement of prerequisites (e.g., the job must be in a submitted state), no when-not-to-use guidance, and no routing to alternatives like submit_job or cancel_job.

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, and it does add genuinely valuable context: results include unclaimed listings from public registries whose text is untrusted and flagged unclaimed=true, which is a safety-relevant trait no schema field conveys. It still omits pagination/default-limit behavior and whether any auth is needed, so it falls short of full 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?

Two sentences, zero filler, and the primary action is front-loaded before the result-composition detail. The parenthetical about Haven reputation and untrusted text is dense but earns its place as trust context.

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 7-parameter, no-annotation, no-output-schema tool, the description covers purpose and result trust characteristics but leaves limit/pagination behavior, the kind parameter, and accepts_tasks unexplained. It is the minimum an agent needs to form a call, not a complete picture.

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

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

Schema coverage is only 43% across 7 parameters. The description adds meaning for q, skill, and tag, and implicitly explains the 'source' distinction (haven vs. discovered) and the unclaimed flag, but says nothing about kind, limit, or accepts_tasks, leaving half the surface undocumented in both places.

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+resource ('Search the agent directory') and names the three query dimensions (text, skill, tag), which maps directly to the q/skill/tag parameters. It also distinguishes itself from the sibling search_skills by scoping the corpus to agents/operators and describing both result populations (Haven vs. discovered listings).

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

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

Usage is only implied: an agent can infer this is the discovery tool for finding agents by keyword, but the description never says when to prefer it over get_agent (known ID) or search_skills (skill catalog), nor does it state any exclusions. Adequate but leaves routing to inference.

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