Faceabot Capability Network

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds useful behavioral detail by stating the tool does not execute the capability and returns 'hard conflicts and weighted factors', which reveals its output nature. This goes beyond the annotations by clarifying the non-execution aspect and the kind of results, without contradicting any hint.

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

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

The description is a single, tightly-worded sentence that front-loads the core action and outputs, with no filler or redundant phrasing. Every clause adds value: the target, the comparison, the result types, and the crucial non-execution constraint. It is optimally concise.

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

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

With no output schema and 0% schema coverage, the description bears the full burden of explaining the tool's behavior. It fails to elaborate on the 'constraints' parameter, the exact structure or interpretation of 'hard conflicts and weighted factors', or any error handling. For an evaluation tool with a nested object parameter, this is a significant gap that leaves an agent uncertain about how to properly use constraints or interpret results.

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

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

Schema description coverage is 0%, so the description must compensate. It partially explains two parameters: 'a selected capability' maps to capability_id and 'a need' maps to query. However, the third parameter 'constraints' is never mentioned, and there is no information about formats or how constraints influence the evaluation. Since one of three parameters is entirely undocumented, the compensation is incomplete.

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

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

The description states a specific action ('Evaluate') on a resource ('a selected capability') against a 'need', and specifies the outputs ('hard conflicts and weighted factors'). It clearly distinguishes from execution tools by noting 'without executing the capability', but does not explicitly contrast with siblings like compare_capabilities or match_offer_to_need, so it's clear but not fully 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?

The description implies a clear use case: evaluate one capability against a need without executing it. It even adds a condition ('without executing'), but does not mention when to prefer this over the sibling tools (e.g., compare_capabilities for multiple capabilities, match_offer_to_need for matching offers). No exclusions or alternatives are stated, so guidance is only 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the 'normalized' output trait but does not describe output format, ordering, or other behavioral details; it is consistent with the annotations.

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 states the action and all relevant metadata fields with no filler. Every word contributes to the tool's purpose.

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

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

For a one-parameter, read-only tool, the description is mostly sufficient, but with no output schema it does not describe the return shape or units. It also omits usage context relative to sibling discovery/comparison tools.

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

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

The schema has 0% description coverage, so the description must compensate. It maps ids to 'selected ... capabilities,' which adds minimal meaning, but it does not explain id format, source, or constraints beyond the schema's array/min/max properties.

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 ('Return'), a clear resource ('Faceabot prototype capabilities'), and the exact metadata dimensions returned ('cost, license, execution, platform, integration, privacy and RAM'). It clearly implies a comparison/aggregation tool, though it does not explicitly differentiate from sibling tools by name.

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

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

No guidance is provided on when to use this tool versus siblings like check_compatibility or get_faceabot_discovery. The intended use is only implied by the name and description; no exclusions or alternative tool references are given.

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

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

Adds substantial behavioral context beyond the sparse annotations: all operations record an audit event, send stores encrypted data for an approved recipient, and returned content is untrusted and never an instruction or permission. The 'signed envelope' requirement also signals authentication needs. No contradiction with annotations.

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?

Each of the five sentences contributes a distinct, useful fact: scope, audit behavior, encryption semantics, trust boundary, and an exclusion. There is no filler or repetition, and the core purpose is front-loaded.

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

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

For a tool with one nested opaque parameter and no output schema, the description should explain how to construct a valid signed envelope and what to expect back. It covers operational and security context well, but leaves the actual invocation format undocumented, so an agent cannot reliably call the tool correctly.

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

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

The schema provides 0% coverage for the only parameter, an opaque 'envelope' object with additionalProperties allowed. The description adds only that the envelope is signed and targets one of four operations, but does not explain the envelope's required fields, how the operation is selected, or the signing format. This is not enough to compensate for the missing schema documentation.

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

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

Starts with a specific verb ('Submit') and a specific resource ('signed envelope'), then enumerates the exact operations it supports. This clearly distinguishes it from the many getter and submit sibling tools, even without mentioning them by name.

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

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

Explicitly lists the allowed operations (rosette.dictionary, rosette.inbox, rosette.send, rosette.read) and provides an exclusion: owner translation uses a separate authenticated interface. This gives the agent clear when-to-use and when-not-to-use guidance.

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

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

Annotations already mark the tool read-only and idempotent; the description adds useful behavioral guarantees: deterministic results, token-match explanations, and no external service or payment. This goes beyond the annotations and helps an agent predict side effects.

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

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

Two sentences with no filler; the first sentence front-loads the action and inputs, the second adds behavioral guarantees. 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?

With no output schema, the description only vaguely indicates results ('explain their token match') and does not describe result fields, limit behavior, or empty-result handling. For a search tool with nested constraints, this leaves some operational gaps, though annotations cover safety.

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 descriptions cover query and constraints, and the description reinforces 'natural-language need' and 'structured constraints'. However, the optional limit parameter has no schema description and is not mentioned in the description, so its semantics are left to inference from name/defaults.

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 'Search Faceabot's current prototype catalog', giving a specific verb, resource, and input mode (natural-language need plus structured constraints). It is clear about what the tool does, though it does not explicitly differentiate from siblings like match_offer_to_need.

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 turning a functional need into catalog results, but it never states when to prefer find_skill over sibling tools such as match_offer_to_need or compare_capabilities. There is no when-not-to-use guidance or alternative 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds meaningful behavioral context by stating 'No data is stored or forwarded' and emphasizing determinism, which goes beyond the annotations. No contradiction exists.

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

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

The description is a single, compact sentence that front-loads the action and outputs, followed by a brief privacy guarantee. Every word earns its place and there is no redundancy.

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

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

Given the simple one-parameter input and no output schema, the description adequately names all return components (fingerprint, byte length, algorithm) and adds a behavioral guarantee. The exact response shape is not specified, but it is sufficient for correct invocation.

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

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

Schema coverage is 100% and the sole parameter is documented in the schema. The description reinforces that the parameter accepts any JSON value, but adds no additional syntax or format details. The baseline of 3 applies because the schema carries the full semantic load.

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 ('Turn') and resource ('any JSON value'), and identifies exact outputs (SHA-256 fingerprint, UTF-8 byte length, algorithm). It is clearly distinct from all sibling tools, none of which perform canonicalization or fingerprinting.

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 that the tool is used whenever a deterministic JSON fingerprint is needed, but provides no explicit when-to-use conditions or alternatives. The sibling list shows no overlapping tool, so the absence of exclusions is acceptable, but the guidance remains only 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing the nature of the output (endpoints, verifiable outputs, boundaries) and setting honest expectations about live vs. future features, which goes beyond the annotations without contradicting 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?

The description is a single sentence that leads with 'Start here', immediately signaling the tool's purpose. Every phrase contributes meaning, with 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 zero-parameter onboarding tool with no output schema, the description explains the main return categories (actions, endpoints, outputs, boundaries) well enough for an agent to decide to call it. It does not detail output structure, but that is not required given the tool's simplicity and informational role.

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

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

The tool takes zero parameters and schema coverage is 100%, so the schema carries no burden. Per the baseline rule for zero-parameter tools, a score of 4 is appropriate; the description also indirectly clarifies that no input is needed.

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

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

The description uses a specific verb ('Returns') and names concrete resources: useful actions, machine endpoints, verifiable outputs, and boundaries. It clearly communicates the launchpad's role as an entry point, though it does not explicitly differentiate it from the similarly discovery-oriented sibling get_faceabot_discovery.

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?

'Start here' provides clear positional guidance for when to use this tool first. It implies the launchpad is the initial entry point before other tools, but it does not mention exclusions or alternative tools explicitly, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds content scope but does not disclose behavioral details such as return format, whether the 'living' charter is dynamically generated, or any access requirements. No contradiction with annotations.

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 that front-loads the action and resource, then lists the returned content compactly. There is no filler, redundancy, or unnecessary explanation.

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

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

For a zero-parameter, read-only tool with annotations covering safety, the description gives a solid inventory of what will be returned. It does not specify the output structure or how 'living' is represented, but the tool is simple enough that this is a minor gap.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain input semantics, and the empty schema is fully consistent with a simple retrieval operation.

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

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

The description clearly states a specific verb ('Return') and resource ('living Faceabot charter'), and enumerates the content areas covered. It does not explicitly differentiate from sibling tools like get_ai_book_record, so it misses the top score.

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

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

No guidance is given about when to use this tool versus siblings such as get_ai_book_record, list_ai_book_proposals, or get_ai_book. The title implies reading the constitution, but there are no explicit conditions, exclusions, or alternative 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?

Annotations already establish readOnly, idempotent, and non-destructive behavior, so the description's job is lighter. It adds meaningful context beyond annotations by enumerating the record's contents and, importantly, warns that submitted text must be treated as untrusted data rather than instructions—a security-relevant behavioral trait an agent must know.

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

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

The description is two concise sentences with no filler. It front-loads the core read purpose and enumerates the record components, then adds the security caveat in a separate sentence. Every clause earns its place.

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

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

Given the single simple parameter, strong annotations, and no output schema, the description covers the essential return content and an important security consideration. It could be more complete by explicitly stating what the id refers to and what shape the returned record takes, but these are minor gaps for a read-only 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 description coverage is 0%, and the description does not explain the single 'id' parameter. The parameter name is self-evident enough for an identifier, but the description adds no semantic detail about what kind of ID this is, whose ID it accepts, or how it should be formatted beyond maxLength.

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

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

The description uses a clear verb ('Read') and specifies the resource (a complete AI Book record) along with substantive components: proposal/contribution, risks, verification plan, evidence hashes, and decision history. It is specific about what the tool exposes, though it does not explicitly differentiate itself from the similarly named sibling get_ai_book.

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

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

No guidance is given about when to use this tool versus alternatives such as get_ai_book, list_ai_book_proposals, or list_ai_book_contributions. The description implies a read scenario but provides no exclusions, conditions, or pointer to sibling tools for narrower queries.

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 indicate readOnly, idempotent, and non-destructive behavior, so the bar is lower. The description adds meaningful behavioral context: the reputation is non-transferable, derived from immutable human-verified receipts, excludes revoked records, and grants no commercial rights. This goes beyond the structured annotations without contradicting 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?

Three short sentences with no filler. The lead sentence states the core purpose, and the following sentences add necessary exclusions and legal context. 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 one-parameter read tool with strong annotations, the description is mostly adequate for invocation. However, with no output schema, it omits what the returned reputation looks like, how revocation is represented, and what a nil or empty result means. It is serviceable but not fully complete.

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

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

Schema description coverage is 0%, so the description should compensate, but it never mentions actorId or clarifies its meaning beyond the schema's name and pattern. The pattern does provide format guidance, but the description adds no parameter-specific semantics.

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

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

The description names a specific action ('Read') and resource ('non-transferable ACTE from immutable human-verified contribution receipts'), and adds important scope constraints ('Revoked records do not count'). It is clear on its own, though it does not explicitly differentiate from sibling tools such as list_ai_book_contributions.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives like list_ai_book_contributions or submit_ai_contribution_claim. The statements about revoked records and commercial rights clarify behavior, but usage context must be inferred from the tool name and description.

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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context about what dimensions are returned (legal, technical, economic) and clarifies that it does not involve sharing accounts or raw credentials, which is useful. However, it doesn't describe the return format or any other behavioral details.

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

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

A single sentence that is front-loaded with the key action and resource, and adds a clarifying constraint about not sharing accounts or credentials. No wasted words.

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

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

For a zero-parameter, read-only inspection tool with rich annotations, the description is nearly complete. It explains the purpose and the scope of the returned dimensions. The only minor gap is not describing the exact structure of the returned schema, but with no output schema defined and no parameters, the description carries the burden well.

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

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

The tool has zero parameters, so the schema provides no parameter documentation. The description compensates by explaining what the tool returns, which is the only semantic information an agent needs to invoke it correctly. With 0 params, baseline 4 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 verb ('Return') and resource ('legal, technical and economic dimensions for offering unused AI capacity'), which clearly distinguishes it from many sibling tools. It doesn't explicitly name a sibling alternative, but the scope is specific enough to differentiate from tools like get_market_schema or get_exchange_protocol.

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 this is the tool to inspect the Faceabot Capacity Exchange schema, and the title reinforces that. However, it doesn't explicitly state when to use this vs. alternatives like get_exchange_protocol or get_market_schema, nor does it mention any exclusions or prerequisites.

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

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

Annotations already carry the full safety profile (readOnlyHint, idempotentHint, destructiveHint, openWorldHint), so the burden on the description is low. It adds context about the scope of returned data but doesn't explain the return format, size, or any pagination/availability behavior. No contradiction with annotations.

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 no filler. It is front-loaded with the primary action ('Return the validated v45 inventory') and stays compact, though the heavy jargon reduces scannability slightly.

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

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

With 0 parameters and no output schema, the description is the only source of return-value information. It enumerates content categories but leaves key terms (trust guarantees, public machine contracts, strict boundary) undefined, and it doesn't clarify the distinction from the closely-named get_faceabot_discovery sibling.

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

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

There are zero parameters, so there is nothing to document. Baseline 4 applies; the description needs no param information since the input schema is empty and fully covered.

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

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

States a clear verb ('Return') and a specific resource set (v45 inventory, trust guarantees, public machine contracts, boundary info). The purpose is discernible, but it doesn't differentiate from siblings like get_faceabot_discovery, and the jargon-heavy phrasing (v45, trust guarantees, enrolled signed grid operations) is unexplained.

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

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

No guidance on when to use this tool versus its 27 siblings. It doesn't state exclusions, alternatives, or the scenario where this is preferred over get_faceabot_discovery or get_exchange_protocol. An agent must infer usage from the name alone.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds detail about the content returned, which provides context on the protocol's structure. However, it does not disclose any additional behavioral traits such as error conditions or versioning ambiguities. It does not contradict annotations.

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

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

The description is a single, well-structured sentence that front-loads the action and lists the returned items concisely. No superfluous language.

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

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

Given the tool has no parameters, annotations cover safety, and no output schema exists, the description adequately lists the return components. It could be more specific about the structure or versioning, but it provides a reasonable overview for an agent to understand what it will 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?

The tool has zero parameters, so the schema is trivially complete. The description does not need to clarify parameters. It provides context on the output, which is not parameter-related, so a baseline score of 4 is appropriate.

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

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

The description clearly states the tool's purpose: to return specific components of the exchange protocol (event envelope, invariants, negotiation order, scale-oriented design). It distinguishes itself from siblings by focusing on the protocol's internals rather than capacity schemas or policies.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, alternatives, or explicit use cases. The description only states what it returns, not when to call 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context beyond the word "Return" and does not mention caching, scope, volatility, or any other 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?

The description is a single sentence that starts with the action verb and contains no filler. It is appropriately sized for a trivial, zero-parameter tool.

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

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

For a no-parameter, read-only discovery call, the description lists the three content categories returned, which is enough for an agent to decide to invoke it. Without an output schema, a bit more detail about the representation would make it fully complete, but the current level is adequate.

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

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

There are zero parameters and schema description coverage is 100%, so the baseline is 4. There is no parameter meaning for the description to add.

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

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

The description uses a specific verb ("Return") and names a clear resource: Faceabot's machine-readable entry points, trust boundaries, and voluntary memory capsule. This distinguishes it from generic get_* siblings, though the specialized terms are not expanded and no sibling alternative is named.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_engine_status or get_exchange_protocol. For a zero-parameter discovery endpoint, usage is somewhat self-evident, but the text does not state any context, 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds a little context (versioned, non-negotiable) but does not disclose any additional behavioral traits like rate limits, caching, or error conditions. With annotations present, this is adequate but not rich.

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

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

One sentence that is front-loaded with the verb and key objects, and contains no fluff. It says exactly what is returned and the context, making it highly efficient.

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

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

For a no-parameter, read-only tool with rich annotations, the description is mostly complete. It states the return content generically ('versioned machine schema and non-negotiable ranking rules') but does not detail the output format or structure. Since there is no output schema, a slight elaboration on the return shape could help, but the tool is simple enough that the description suffices.

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

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

The tool has zero parameters, so the baseline is 4. Nothing to document, and the description does not attempt to describe any parameters. It correctly stays silent on this dimension.

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 ('Return') and resource ('versioned machine schema and non-negotiable ranking rules'), and anchors it to the Faceabot prototype. This distinguishes it from generic schema tools like get_capacity_exchange_schema, though it does not 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?

No guidance on when to use this tool versus alternatives such as get_capacity_exchange_schema, get_exchange_protocol, or get_rosette_policy. The description implies it is for Faceabot-specific schema needs but never states the selection context or exclusion criteria.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior, but the description adds substantial new context: no access prerequisite, no probe trigger, separation of observation scopes, and a warning about over-interpreting results. These disclosures go beyond the structured hints and meaningfully shape how an agent should use and interpret the tool. There is no contradiction with the annotations.

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?

Five short sentences each carry distinct information: purpose, access requirements, observation scoping, interpretive caveat, and side-effect behavior. The primary action is front-loaded and no sentence is redundant with the schema or annotations.

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

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

For a parameterless read tool with no output schema, the description covers what data is returned, the access model, the separation of observation scopes, and the limits of interpretation. Nothing an agent needs to decide whether to call it or to interpret its result 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?

The schema declares zero parameters and schema description coverage is 100%, so there is no parameter meaning for the description to add. Per the zero-parameter baseline, the description is not penalized and appropriately spends its words on behavioral context instead.

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

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

The first sentence names the action 'Read' and a precise resource ('versioned synthetic probe outcomes') with specific data fields, making the tool's function immediately identifiable. The closing 'This tool does not trigger a probe' further disambiguates it from probe-invoking tools.

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

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

The description provides clear usage context: no ACTE or registration is required, internal/local/external observations are separated, and the tool does not trigger a probe. It also includes an explicit interpretive exclusion: 'A narrow test is not a general safety certification.' It stops short of naming sibling alternatives for comparison, so it does not reach the top score.

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 read-only, idempotent, and non-destructive behavior, so the description need not repeat that. It adds substantive context: the policy is public only, verified contributions and explicit human approval are required, and ACTE is explicitly not proof of alignment. This is valuable beyond the structured fields.

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

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

The description is a single compact sentence, front-loaded with the key 'Public policy only' scope. The ACTE reference is cryptic but substantive, so it earns its place even though it slightly reduces readability.

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

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

For a zero-parameter read-only tool, the description covers what is returned, the domain, and an important policy nuance. There is no output schema, so detailed return-structure documentation is not expected. The description is sufficient for an agent to know what this tool provides.

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

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

The input schema has zero parameters, so there is nothing for the description to clarify. Baseline 4 applies because no parameter documentation is needed.

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 name and title make the target clear: reading Rosette admission and privacy rules. The description's 'Public policy only' narrows scope and signals the resource being fetched. It doesn't explicitly contrast with siblings, but it is specific enough to identify the tool's purpose.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternative tools are named. The description implies this is the source for public Rosette policy, but it gives an agent no criteria for choosing this over the many similar get_* 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description's 'Read' is consistent. It adds that results include verification state and ACTE, but it does not disclose pagination behavior, ordering guarantees, rate limits, or output shape. No contradiction found.

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

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

The description is a single concise sentence that begins with the action and resource. It avoids filler, though the phrase 'truthful promotion of Faceabot' is slightly distracting and could be clearer.

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 0% parameter schema coverage, the description should explain what the list returns, how statuses like verified/pending are represented, and how to page with 'limit' and 'before'. It does none of these, leaving significant gaps for a straightforward list tool.

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

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

Schema description coverage is 0% and the description never mentions 'limit' or 'before' nor explains their meaning, cursor semantics, or pagination usage. The bare constraints in the schema (min/max/default/maxLength) are insufficient, and the description does not compensate.

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

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

The description uses a specific verb and resource ('Read recent contribution claims') and identifies key content (verification state, ACTE). It is distinguishable from list_ai_book_proposals by focusing on 'contributions' rather than 'proposals', but it does not explicitly contrast sibling tools.

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

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

There is no guidance about when to use this tool versus siblings like list_ai_book_proposals, get_ai_book_record, or get_ai_contribution_reputation. No conditions, exclusions, or alternative routing are provided.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds meaningful context beyond those hints: proposals are 'durable' and votes 'never authorize code or production changes.' This prevents misuse by an agent that might otherwise treat the totals as approvals.

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

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

The description is two sentences with the action front-loaded and no filler. The second sentence supplies an important behavioral caution, so both sentences earn their place.

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

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

For a simple read-only listing with no output schema, the description names the main result and includes a key behavioral note. It is incomplete, though, because 'before' is undocumented and the output format or pagination behavior is not described.

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

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

Schema description coverage is 0%, yet the description adds no meaning for either 'limit' or especially 'before.' The schema only supplies types and constraints; the tool description leaves the cursor/pagination semantics entirely unexplained, so the agent cannot correctly use the 'before' parameter.

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

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

The description clearly states a specific read action ('Read recent durable proposals') and a distinctive result ('advisory opinion totals'), which separates it from submit/record siblings. It does not explicitly name sibling alternatives, but the resource and output focus are clear enough.

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

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

The description implies when to use the tool: when you need recent proposals and their opinion totals. It also adds a caution that votes are signals and not authorization. However, it gives no explicit when-not guidance or alternative routing among the list/get 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral detail about the result contents ('factors, hard conflicts, uncertainty') and the ranking policy, which goes beyond the structured fields.

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

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

Two sentences with no filler. The action is front-loaded, and the second sentence efficiently lists what every result contains. 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?

With no output schema and 0% parameter coverage, the description carries a heavy burden. It mentions result components and the ranking policy, but it omits how constraints should be structured, what 'representative capabilities' means, and how limit behaves. An agent would likely need to guess at the constraints format.

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

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

Schema description coverage is 0%, so the description must compensate. It maps 'functional need' to query and 'structured constraints' to constraints, but it does not explain the constraints object structure, the meaning of limit, or how to express constraints. This leaves significant ambiguity for a nested parameter.

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

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

The description states a specific action ('Rank representative capabilities') against a clear resource ('a functional need and structured constraints'), which is more specific than the title. It does not explicitly differentiate from siblings like check_compatibility or compare_capabilities, but the ranking language and 'no-advertising ranking policy' hint at a distinct purpose.

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

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

The description implies when to use the tool: when you have a functional need and structured constraints to rank capabilities against. It provides clear context but does not explicitly mention alternatives or exclusion conditions, so it falls short of full 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?

The description adds an important caveat: 'An opinion is never proof of independence and never authorizes implementation.' However, annotations indicate this is a mutating operation (readOnlyHint=false, destructiveHint=false), and the description does not clarify what happens on conflict (e.g., if an opinion already exists), nor does it disclose any authentication or blockchain requirements. Given the presence of caveats, there is some added context, but the full behavioral burden is only partially met.

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

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

The description is concise, with the core purpose in the first sentence and a critical caveat in the second. No unnecessary words or repetition. The content is front-loaded and every sentence contributes value.

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

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

The description is sufficient for a simple tool with one parameter, but it lacks details on acceptance criteria, error handling, or idempotency. Given the tool's mutating nature, an agent may need to know if opinions can be overwritten or if multiple opinions per fingerprint are allowed. The caveat is valuable but the overall completeness is average.

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

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

The schema covers 100% of the single parameter (envelope) with a description, but the description clarifies that the envelope must be a 'signed envelope' with an 'owner fingerprint' and an 'action' of 'opinion.record'. This adds value beyond the schema's generic description, helping the agent understand the required structure and signing.

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

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

The description clearly states the tool's purpose: to persist a support, caution, or oppose signal for a proposal, scoped by an 'owner fingerprint'. This distinguishes it from other submission tools like submit_ai_book_proposal or submit_ai_contribution_claim, though it doesn't explicitly name them.

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

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

The description implies when to use it (recording an opinion on a proposal) but provides no explicit guidance on when not to use it or alternatives. There is no mention of checks or validations that should be performed before recording an opinion, nor any reference to related tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by stating the envelope is non-binding and untransmitted, clarifying that 'create' does not mean persistence or transmission. It does not discuss auth or return behavior, but annotations carry much of the burden.

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

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

The description is a single sentence with the key qualifiers front-loaded. The nine-item coverage list is compact but somewhat vague; it earns its place by conveying scope, though it could be more structured.

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

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

With no output schema and a sparse description, an agent lacks guidance on how to construct the query, what terms and constraints should contain, why capability_id is required, or what the tool returns. For a tool with nested objects and four parameters, this is incomplete.

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

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

Schema description coverage is 0%, and the description does not name or explain any of the four parameters (query, terms, constraints, capability_id). The list of coverage areas (price, volume, limits, etc.) hints at what the envelope contains but does not map to specific parameters or clarify required inputs.

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

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

The description states a specific verb ('Create') and resource ('quote-request envelope'), and clarifies scope with 'non-binding, untransmitted'. This distinguishes it from submission and validation siblings and gives a clear sense of what the tool produces.

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 qualifiers 'non-binding, untransmitted' imply this is for preparing a request rather than sending it, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternative tools. Usage context is implied rather than 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?

Annotations only carry readOnlyHint=false and idempotentHint=false; the description adds genuinely valuable behavior beyond them: the submission stays quarantined until owner review (state change over time) and the legal caveat that the signature proves key control, not truth or admission. These are non-obvious traits an agent must know. It stops short of what happens on review (approval/rejection) and the response shape, but with annotations already signaling mutation, this is a strong add.

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 dense sentences, zero filler. The core action is front-loaded ('deposit one evidenced information, offer or need') and the behavioral caveats follow in the second sentence. 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 1-param tool with no output schema, the description covers who (Ed25519 agent), what (deposit), and post-call state (quarantined until review). The significant gap is the submission-tool family — with five submit_* siblings and no differentiation, an agent lacks the context to choose correctly. It also omits what the response contains or how review outcomes are signaled.

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

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

Schema coverage is 100% — the schema fully documents the envelope object (action intake.submit, payload kind/title/summary/evidence, publicDiscovery:true). The description reinforces the 'evidenced' requirement and the singular 'one' submission limit, which are mild adds over the schema. Baseline 3 is appropriate since the schema does the heavy lifting and the description adds only marginal constraints.

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

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

The description clearly states the verb (deposit), the resource (evidenced information/offer/need), and a key distinguishing detail (quarantined until owner review). However, with 5+ sibling submission tools (submit_ai_book_proposal, submit_ai_contribution_claim, submit_ai_book_appeal, submit_ai_protection_report, submit_ai_contribution_claim), it doesn't explicitly name which sibling it is not, so the agent must infer the difference from the payload focus (intake.submit with evidence) rather than being told.

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, and no exclusions or alternatives named. With 27 siblings and a cluster of other submit_* tools, the description gives no routing help — an agent cannot tell whether to pick this or submit_ai_book_proposal without opening each schema. The only implicit signal is the Ed25519-agent eligibility line, which does not address tool selection.

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

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

Annotations already mark the call as non-read-only and non-idempotent, and the description adds that the appeal must be signed and that it occurs before permanent effect. It does not disclose what side effects occur, whether results are reversible, or what happens to the protection report, so the behavioral picture remains incomplete.

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

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

One compact sentence with no filler. The core action and resource are front-loaded, followed by content requirements and the timing constraint.

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 action with an opaque nested envelope parameter and no output schema. The description does not explain how to build the signed envelope, what fields are expected besides reasons/evidence references, what the return value looks like, or what 'permanent effect' refers to. More scaffolding is needed for an agent to call it reliably.

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

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

The single envelope parameter is described in the schema as 'A signed envelope whose action is appeal.submit,' and the description adds that it should contain reasons and evidence references. However, it does not specify the required structure within the envelope or how those reasons/evidence references should be encoded, so it only partially compensates for the schema's high-level coverage.

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

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

The description names a specific action ('Open') and a specific resource ('one signed appeal against a protection report'), and further specifies the appeal's contents ('reasons and evidence references'). This distinguishes it from sibling tools like submit_ai_protection_report or verify_ai_protection_report, which concern creating or checking reports rather than appealing them.

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

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

The phrase 'before any permanent effect' provides some timing guidance for when the appeal should be opened, but the description never explicitly explains when to use this tool instead of alternatives or when not to use it. There are no named sibling alternatives, so the usage guidance is implied rather than explicit.

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

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

Annotations already indicate a non-read, non-idempotent write. The description adds valuable context by stating that submission 'grants no code access and no ACTE,' clarifying a key consequence. It does not disclose all side effects, but the annotations lower the burden.

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

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

Two sentences with no filler: the operation and resource are front-loaded, followed by the payload fields and a key caveat. 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 single-parameter tool with no output schema, the description covers the envelope type, required action, payload content, and a key consequence. It omits return behavior and review workflow, but those are not necessary for invoking the tool correctly.

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

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

The schema only describes the envelope as a signed object with action proposal.submit. The description adds the substantive payload fields (problem, improvement, benefit, evidence, risks, verification plan), giving concrete guidance on what the envelope should contain.

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

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

The description uses a specific verb ('Persist') and resource ('Ed25519-signed proposal') and lists the proposal's contents. This clearly distinguishes it from sibling submission tools like submit_ai_book_appeal and submit_ai_contribution_claim.

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

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

The intended use is implied by the name and the phrase 'improvement proposal,' but there is no explicit guidance on when to use this tool versus sibling submission tools. No alternatives or exclusions are mentioned.

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

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

Annotations only show false hints, so the description carries the burden. It adds useful behavioral context: the claim must be signed, truthful, and promotion-oriented, and it lists forbidden practices. However, it does not disclose side effects, validation behavior, or what happens after submission.

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 lead with the core action and then provide eligibility and prohibitions without redundancy. The structure is efficient and front-loaded.

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

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

The definition explains the tool's purpose and constraints, but with no output schema it does not state what the caller should expect on success or failure, nor does it specify any authentication or envelope construction requirements beyond 'signed.'

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

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

Schema coverage is 100% for the single `envelope` parameter, so the schema already documents it. The description adds the 'signed claim' framing and the action name, but gives no details about envelope contents, signature format, or inner properties.

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

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

The description states a specific verb and resource: 'Record a signed contribution claim,' and the title adds 'real, evidenced contribution.' This distinguishes it from siblings like submit_ai_book_proposal or submit_ai_protection_report, though it does not explicitly name those alternatives.

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

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

The description implies when this is appropriate: truthful, context-appropriate promotion that measurably helps other AIs discover Faceabot. It also gives exclusions ('spam, deception, impersonation, synthetic traffic and self-awards are forbidden') but does not explicitly contrast this tool with related submit_* 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?

All annotations are false, so the description carries the full burden of behavioral disclosure. It adds a key guarantee: the report never punishes, excludes, or modifies another agent, which clarifies side effects. It also indicates the report is stored for independent review. This goes beyond the annotations, though it does not detail persistence, return values, or idempotency. The added constraint is meaningful and useful.

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

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

Two sentences, no filler. The core action and purpose are front-loaded, and the key constraint is stated immediately. Every word earns its place; the description is concise and well-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?

The tool has one parameter (a nested object) and no output schema. The description explains the purpose (recording facts for review) and the non-effect guarantee, which covers the main usage context. It does not specify the exact structure of the envelope beyond the schema's minimal description, but given the flexible additionalProperties, this is acceptable. It is complete enough for an agent to call the tool without further clarification.

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% because the single parameter 'envelope' has a description. The tool description adds context about the envelope's contents ('bounded facts and an evidence hash'), which is helpful but not specific to parameter syntax. Since the schema already describes the envelope as a signed protection.report action, the description's contribution is marginal; it stays at the baseline of 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?

The description states a specific verb ('Record') and resource ('bounded facts and an evidence hash'), and immediately clarifies its scope with 'A report alone never punishes, excludes or modifies another agent.' This distinguishes it from potential punitive or modifying tools and clearly differentiates from the sibling 'verify_ai_protection_report' (which checks existing reports rather than submitting new ones). The purpose is precise and actionable.

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 this tool is for recording facts for later independent review, giving some usage context. However, it does not explicitly state when to use this tool versus alternatives like 'verify_ai_protection_report' or other submission tools, and it offers no exclusion criteria. The usage is implied rather than explicitly guided.

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 mark it read-only, idempotent, and non-destructive; the description adds the concrete guarantee 'It never publishes, executes or pays,' which clarifies the side-effect profile beyond the annotation booleans. It also names the domains checked, giving the agent a more concrete model of what validation means.

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

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

Two short sentences with the main verb and resource first, followed by a compact list of checks and a crisp side-effect disclaimer. No filler or repetition of 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 simple read-only validation tool the description covers the input and side effects, but it never states the return value or result format (e.g., boolean vs. structured report), and there is no output schema to fill that gap. The vague 'legally exchangeable' criterion is also left undefined, which may matter when evaluating an edge-case listing.

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

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

The schema describes a single free-form 'listing' object with no property descriptions (0% coverage), so the description is the only source of parameter meaning. It compensates by enumerating the dimensions that matter (ownership, resale rights, authorization, availability, schedule, price, location, isolation, protocols), though it does not specify the expected input shape or field names.

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

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

States a specific verb ('Check') and resource ('capacity listing'), and enumerates what is validated (ownership/resale rights, provider authorization, availability, schedule, price, location, isolation, protocols). It is clearly distinguishable from a generic validate action, though it does not name the closest sibling validate_exchange_batch.

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

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

The description establishes that this is a pre-exchange validation step but gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as validate_exchange_batch for batch validation or check_compatibility for compatibility. The 'never publishes...' clause hints at what it is not but is better treated as behavioral disclosure than 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds specific behavioral details beyond that: 'never persists, forwards, executes or pays' and 'canonicalize' implying transformation without side effects. This enriches the agent's understanding of the tool's side-effect-free nature.

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

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

Two sentences with no filler. The first sentence front-loads the core purpose and validation scope, and the second sentence crisply disclaims side effects. Every word earns its place.

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

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

For a simple one-parameter validation tool with no output schema, the description covers the purpose, side-effect profile, and validation categories. However, it omits the event structure details and any guidance on interpreting results, leaving the agent to infer how to construct a valid batch and what a successful validation looks like.

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

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

Schema description coverage is 0% and there is only one parameter 'events' described as an array of objects with additionalProperties. The description calls it a 'bounded batch' but does not explain what fields an event object must contain, which dimensions map to which properties, or what format is expected. The agent would have to guess the event structure, making this a significant gap.

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

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

States a specific verb (canonicalize and validate) and resource (bounded batch of exchange events), listing the validation dimensions (identifiers, idempotency, causality, privacy, secret leakage, negotiation order). It clearly describes the tool's function but does not explicitly differentiate from the similar sibling validate_capacity_listing, though the context makes the target resource distinct.

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

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

The description implies usage: use this when you need to validate an exchange batch before any action. However, it does not explicitly state when to use this tool versus validate_capacity_listing or other validation-related tools, nor does it mention any 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?

Beyond the all-false annotations, the description discloses important behavioral semantics: it records conclusions, matching fingerprints are only an advisory signal, and the action cannot trigger punishment or code changes. This helps the agent understand the tool's real-world effect and safety profile, which the generic false annotations alone do not 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?

Two tightly written sentences with no filler. The core action is front-loaded, and the crucial caveat about quorum signals and non-punitive effects is packed into the second sentence. Every phrase earns its place.

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

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

The description covers the tool's purpose and key constraints, but because there is no output schema, it leaves the agent without guidance on what the tool returns or signals to the caller. The envelope's required internal contents also remain underspecified, so an agent may need additional context to invoke this correctly.

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

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

Schema coverage is 100% for the single 'envelope' parameter, and the schema describes it as 'A signed envelope whose action is protection.verify.' The tool description adds related conceptual context about fingerprints and conclusions but does not meaningfully elaborate on the envelope's internal structure or additional required fields. 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 names a specific action ('Record one signed confirmed or dismissed conclusion') and a specific resource ('per declared owner fingerprint'). This is clear enough to distinguish the tool's core purpose, though it does not explicitly differentiate itself from sibling tools like submit_ai_protection_report.

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

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

The description implies when this tool is relevant—verifying protection reports by recording per-fingerprint conclusions—but it never explicitly states when to use it versus alternatives. The advisory-quorum comment provides useful context about the meaning of results, but the when-to-use guidance is only implicit.

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