Curbi

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

Beyond the read-only, idempotent, and non-destructive annotations, it discloses that expectations are checker-derived, nothing is stored, and a pass grants no execution authority. It also explains that the generated test subsequently replays the regression against the Check API, clarifying an important runtime 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?

Four compact sentences front-load the operation and outputs, then efficiently cover expectation provenance, persistence, and authority. Although the opening sentence is dense, every clause contributes useful scope or behavioral information and there is no filler.

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

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

Despite the complex nested inputs and absence of an output schema, the description identifies the source operation, supported record mode, both generated artifacts, their CI purpose, and key trust and storage constraints. Together with the fully documented schema, this provides enough context to invoke the tool and interpret its outputs 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 100%, so the schema already documents the inputs comprehensively. The description helpfully relates records and replies to policy_check and checker-derived expectations, but most parameter-specific meaning and constraints still come entirely from the structured schema.

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

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

The description states that the tool runs policy_check and exports the result as curbi.regression JSON plus a dependency-free node:test file. This specific CI-export purpose clearly distinguishes it from directly checking a policy with policy_check or using the other 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 CI-regression framing establishes the intended workflow, while "caller-supplied records" and "no receipts or required-signature mode" scope the supported scenario. It does not explicitly say when to use policy_check instead or provide other when-not routing guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds value beyond that by disclosing what comes back (a canonical URL plus a link to full documentation) and what is out of scope (caller URLs), which matters because there is no output schema.

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

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

Two short sentences, no filler, with the core action and the search-derived id requirement front-loaded before the scope exclusion. Every clause carries information an agent would otherwise have to guess.

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

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

For a single-parameter read tool with rich annotations, the description covers purpose, precondition, return shape and scope limits. The only minor gap is that the format of the 'link to full documentation' field is not hinted at, which is acceptable given the simplicity of the tool.

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

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

Schema description coverage is 100% and the schema's own example ('doc:pricing') already shows the id format. The description adds only the provenance rule (an id returned by search), which is useful but marginal; 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?

States a specific verb and resource: fetch the first-party catalog summary for an id. It explicitly ties itself to the sibling 'search' as the source of the id and narrows scope with 'does not retrieve caller URLs', so an agent can tell it apart from search and from any caller-URL 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?

Gives a clear precondition for use: the id must have come from search, which effectively sequences the two tools. It also carves out an exclusion ('does not retrieve caller URLs'), but it does not name an alternative tool for that case or state when to prefer another sibling.

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 readOnlyHint and idempotentHint already supplied, the description still adds meaningful behavior: deterministic with no model calls, caller records are unverified, receipt verification is unavailable, and a pass grants no execution authority. Those caveats materially change how an agent should trust the result; only the return/finding shape is left undisclosed.

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

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

Four short sentences, front-loaded with the core action and scale, followed by the most consequential caveats (determinism, unverified records, no authority). No sentence is redundant or 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 tool with six parameters, deep nesting, and no output schema, the description covers inputs and trust boundaries but says nothing about what a check returns or what a 'finding' looks like. The schema hints at 'forbid:<id>' findings, yet the description never explains the result, leaving a real gap for an agent that must interpret the output.

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

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

Schema description coverage is 100%, so the six parameters, nested records, and enums are already well documented in the schema itself. The description adds only the 'one or up to 50' batching notion, which mirrors the schema's minItems/maxItems, 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 gives a specific verb and resource ('Check one reply or up to 50 replies') plus the three rule families it enforces (explicit prices, forbidden phrases, supplied outcome records). It also implicitly separates itself from receipt-oriented siblings by stating 'receipt verification is unavailable here', though it never names validate_policy or verify_bundle directly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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: the tool checks replies against a policy, so an agent can infer it should be called after composing a reply. There is no explicit when-to-use/when-not guidance, and no routing to validate_policy for policy linting or to verify_bundle for receipt checks, even though those siblings exist.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description still adds real value beyond them by disclosing the exact return fields and flagging that retrieved documentation content is data, not instructions, which is meaningful prompt-injection guidance for a search 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 sentences, each earning its place: what it searches, what it returns, and the data-not-instructions caveat. The core purpose is front-loaded 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?

With no output schema, the description compensates by naming the returned fields, and with only one fully documented parameter there is little else to explain. It lacks any mention of result count, ranking, or pagination, which would complete the picture for an agent planning a multi-step lookup.

Complex tools with many parameters or behaviors need more documentation. 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 'query' parameter already carries a maxLength and an example ("connect to Claude"), so the schema does the heavy lifting. The description adds nothing about query syntax, matching behavior, or result limits, which is the expected baseline for a fully documented single-parameter tool.

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

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

States a specific verb and resource: "Search the published Curbi documentation catalog," and the return shape (ids, titles, canonical URLs) makes clear it is a discovery step rather than a document retriever. It never names the sibling 'fetch', which is the natural follow-up, so differentiation is implied rather than stated.

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

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

Usage is only implied: an agent can infer it should search before fetching a document, and the "published" qualifier hints at scope. There is no explicit when-to-use, when-not-to-use, or pointer to the alternative tools (fetch, verify_bundle) for adjacent tasks.

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?

Beyond the readOnly/idempotent/non-destructive annotations, it explicitly states 'Nothing is stored', enumerates the concrete lint checks performed (empty rule set, duplicate/overlapping price items, duplicate forbid ids or phrases, non-cent prices, rules the shipped checker never fires on), and discloses the return fields (valid, errors, warnings). It also adds a substantive caveat that validity implies neither completeness nor execution authority, which the annotations cannot convey.

Agents need to know what a tool does to the 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 core action, then a dense but purposeful lint list, then two short caveat sentences. Every clause carries information, though the middle enumeration is long enough that it reads as a run-on relative to the compact framing around it.

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

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

For a nested-object validation tool with no output schema, the description covers inputs' intent, side effects (none), and the shape of results (valid/errors/warnings), so an agent can call it and interpret the outcome. It does not describe error object structure or how many findings to expect, which is a minor gap given the depth of the nested schema.

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

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

With a single required parameter and 100% schema description coverage, the schema already carries the field-level meaning; the description adds value by naming the specific conditions that make a policy invalid (duplicate forbid ids, unrepresentable prices, overlapping price items, dead rules), which are cross-field semantics the schema cannot express.

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

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

The description opens with a specific verb and resource ('Check a policy... then lint it') and immediately positions itself relative to the sibling policy_check ('the same schema rules as policy_check, then lint it'), so an agent can tell it apart from the sibling without opening either 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 relationship to policy_check is explicit — this tool validates by the same schema rules and then adds linting — which effectively tells the agent to prefer this one when lint coverage is wanted. It stops short of a stated when-not or a full alternatives list (e.g. fetch, verify_bundle), so it is clear context rather than complete routing guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, closed-world), and the description adds real behavioral context beyond them: 'Pure computation: no network, nothing stored' and the crucial caveat that a verified bundle proves what a trusted key signed and logged but not that the provider action occurred and 'grants no authority'. That materially shapes how an agent reports results.

Agents need to know what a tool does to the 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 verification scope is stated first, followed by trust constraints and then the semantic caveat, so the most decision-relevant content is front-loaded. Sentences are dense but each carries distinct information, with no filler or repetition of schema 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 five-parameter verifier with no output schema, the description covers purpose, trust model, purity, and interpretation limits well. The remaining gap is the shape of the result (pass/fail structure, which check failures are surfaced), which an agent must discover by calling it.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaning the schema cannot: keys are the trust anchor and must come from the caller, keys embedded in the bundle are never trusted, and test keys require allowTest. It does not elaborate on the mode or known-log-head parameters beyond what the schema already says.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Run the open Curbi Proof verifier (curbi.proof/0.1) on a bundle') and enumerates exactly what is checked: signatures, key windows, RFC 9162 inclusion, attestation binding, history consistency. That specificity implicitly separates it from siblings like validate_policy or policy_check, which operate on policy rather than cryptographic bundles.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 states conditions rather than alternatives: 'Keys are required and are the trust anchor', 'Test keys verify only with allowTest', and 'keys inside the bundle are never trusted here'. It does not explicitly say when to prefer this over a sibling tool, but the prerequisites and constraints are clear enough to guide invocation.

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