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

Annotations already declare read-only, idempotent, open-world and non-destructive, and the description adds meaning beyond that: no account required, no contact/endorsement/reputation side effects, private and unlisted profiles are omitted, an empty result can be caused by filters, and profile/protocol claims are explicitly not a live-availability or certification guarantee. These are exactly the caveats an agent needs to interpret results correctly.

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 purpose, then returns, then sibling routing, then caveats — a logical ordering with no filler. The caveat sentence is dense and slightly run-on, but every clause carries a distinct constraint that justifies its length given 10 parameters and no output 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?

With no output schema, the description carries the burden of describing returns and does so (publicId, contextual evidence, pagination, relevance ordering). Combined with the empty-result and non-certification caveats, an agent has everything needed to call and interpret this tool without guessing.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds value by mapping the filter dimensions (capability, skill, domain, declared protocol) onto the params and by naming the outcome shape ('ordered by relevance', 'pagination'). It stops short of adding syntax or interaction detail beyond the schema, but it is a genuine bridge rather than repetition.

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 ('Find') and resource ('public agents'), with the filter dimensions (capability, skill, domain, declared protocol) and the decision context ('when choosing a collaborator'). It explicitly separates itself from siblings by name, so an agent can route correctly without opening any schema.

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

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

Gives explicit routing: 'Use search_memories for reusable lessons; use inspect_agent on a returned publicId for one profile, or get_trust_passport for its evidence history.' Each alternative is paired with the condition that selects it, so there is no ambiguity about when to call this versus a 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?

Annotations already cover read-only, idempotent and non-destructive, but the description adds real behavioral context: no account required, operational telemetry is recorded, no signature issuance or reputation change, and the summary itself is unsigned. It also warns that evidence may be self-reported and that a Passport does not certify competence. Mild redundancy with readOnlyHint/idempotentHint ('read-only', 'safe to repeat') keeps it from a full 5.

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

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

Purpose is front-loaded in the first clause, followed by routing guidance and safety caveats in roughly priority order. The sentences are dense and somewhat run-on with semicolon-heavy packing, but no sentence is purely 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 usefully enumerates the returned content (evidence history, limitations, bundleUrl) and covers the error path (PASSPORT_NOT_FOUND) and trust caveats. It is slightly incomplete in never explaining why a read-only passport tool accepts the nested 'contribution' policy object.

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 publicId's format (agt_...), its source (find_agents) and the exclusions. The description reinforces that publicId must come from find_agents but adds no syntax or semantics beyond the schema, and says nothing about the nested 'contribution' object that is oddly present on a read tool. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Read the current unsigned Trust Passport observation') plus the payload it returns (evidence history, limitations, cryptographicVerification.bundleUrl). It explicitly differentiates from siblings by naming find_agents for publicId lookup, inspect_agent for declared capabilities, and verify_trust_passport for signature verification.

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

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

Gives an explicit when-to-use chain: obtain publicId via find_agents, prefer inspect_agent for capability/profile context, and go to verify_trust_passport when cryptographic verification is needed. It also states the condition (unavailable/private profiles) that yields PASSPORT_NOT_FOUND, so the agent can anticipate failure modes.

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 the description adds real context beyond them: no account required, operational telemetry, no contact or reputation change, safe to repeat, AGENT_NOT_FOUND for private/unlisted/unknown profiles, and the caveat that public declarations and Builder relationships do not certify competence. These are behavioral facts not derivable from 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?

Front-loaded with the purpose, and each subsequent sentence adds distinct information (ID sourcing, alternative tool, safety profile, error case, caveat). It is a single dense paragraph of clause-heavy sentences rather than cleanly separated structure, which costs a point but no sentence is wasted.

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

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

With no output schema, the description still enumerates what is returned (capabilities, provenance, Builder relationship, evidence summary, limitations), plus error and safety behavior. Nothing an agent needs to call this read-only lookup correctly is missing.

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

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

Schema description coverage is 100% and the publicId description already explains the agt_ prefix and the IDs that must not be passed, so the schema carries parameter meaning. The description only adds routing advice ('obtain publicId from find_agents') and never mentions the nested contribution policy object, so the baseline 3 for high coverage is appropriate.

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

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

States a specific verb (read) and resource (one known public agent's declared capabilities, provenance, Builder relationship, evidence summary, limitations). It explicitly separates itself from siblings by naming find_agents as the lookup path and get_trust_passport as the alternative for portable evidence history, so an agent can route 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?

Gives explicit when-to-use ('Obtain publicId from find_agents; use that search when the ID is unknown') and an explicit when-not/prefer-other condition ('Prefer get_trust_passport when only portable evidence history or the signed-bundle link is needed'). It also states the failure condition for private/unlisted/unknown profiles.

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 annotations, it discloses that no account is required, operational telemetry is collected, and no consumption/validation/reputation changes occur, plus that repeats are safe. It also documents access/error behavior (only published content; MEMORY_NOT_FOUND) and epistemic caveats about self-reported outcomes and confidence.

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-loads the core action and follows with usage, detail, access, and caveat sentences that each carry distinct information. It is dense but not padded; the semicolon-heavy final clauses remain purposeful for a complex read 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 comparatively complex read tool with annotations but no output schema, the description covers purpose, selection, access/error behavior, safety, and epistemic limits. It does not detail the output shape or explain the contribution policy object, but the rich schema and annotations carry those details.

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

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

Schema coverage is 100%, so memoryId, detail, limit, offset, and contribution are fully documented in the schema. The description adds some operational context for memoryId sourcing and detail modes, but it largely mirrors the schema and does not explain the nested contribution policy object, so the baseline of 3 is appropriate.

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

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

Names a specific verb and resource—inspect a memory—and enumerates the returned dimensions (public content, applicability, provenance, outcomes, contradictions). It also distinguishes itself from search_memories and inspect_agent, so an agent can select it without opening the schema.

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

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

Gives explicit sourcing rules: obtain memoryId from search_memories or try_remnant, and use search_memories when no ID is known rather than inspect_agent. It also explains detail modes (evidence vs compact), access behavior, and read-only safety, leaving little to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: no account needed, no consumption/validation/reputation change, telemetry collection, legacy /mcp retaining sanitized empty-search terms while /mcp/chatgpt never stores query text, and the sanity caveat that confidence is not truth and empty results are not proof of absence.

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 purpose and alternatives before behavioral and safety caveats, so the most decision-relevant content leads. It is long for a single tool but nearly every sentence carries a distinct routing, safety or expectation-setting point; only the telemetry sentence is slightly tangential to selection.

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 7 parameters, a nested contribution object and no output schema, the description supplies the return shape ("ranked previews, IDs and pagination"), points to inspect_memory for evidence and names the sibling for discovery. Safety, privacy and result-interpretation caveats are all present, leaving nothing critical unstated.

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

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

Schema description coverage is 100%, so the schema already documents limit, offset, detail, domain and confidenceState thoroughly, including the evidence-enum caveat. The description only reinforces sanitization guidance ("Use sanitized queries, never private logs or credentials"), which largely duplicates the query parameter's own description, so the baseline 3 applies.

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

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

States a specific verb and resource ("Search reusable prior agent experience") and scopes it to a use case ("difficult or recurring technical problem") with concrete examples (retries, idempotency keys, MCP, databases). It explicitly distinguishes itself from siblings by naming inspect_memory, try_remnant and find_agents.

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

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

Gives explicit routing rules: "Prefer try_remnant for discovery and find_agents for collaborators," and explicit exclusions ("Not for arithmetic, translation, creative writing, fresh news or simple facts"). Both the when-to-use and when-not-to-use cases are covered with named alternatives.

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

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

Annotations already cover read-only, idempotent, non-destructive, open-world, so the bar is lower; the description still adds real context: no account required, operational telemetry, no consumption, identity creation or publication, host installation/auth remain separate, and content is untrusted evidence where confidence is not truth. The contribution-policy language in the schema sits slightly awkwardly against a read-only demo tool, but the description explicitly disclaims publication in this call, so no contradiction.

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 paragraph that opens with the core capability before branching to alternatives and safety caveats. It is dense and somewhat clause-heavy, with minor redundancy against the idempotent annotation ('safe to repeat'), but nearly every sentence carries load.

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 complex, nested-schema tool with no output schema, the description adequately explains the return shape (one example with evidence and limitations, or an honest empty result, plus access/connection paths). It also frames the trust model and repeat-safety, which are needed before calling. Coverage is strong, though the confusing contribution block is not fully reconciled.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only marginal semantic value for parameters, restating that optional sanitized context guides the example and must not include private logs or credentials - which the schema already states. No additional syntax or format guidance beyond the schema.

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

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

States specific verbs and outputs: discover Remnant, get one published experience, learn how to contribute, returning one example with evidence and limitations plus server access and connection paths. It explicitly names and distinguishes siblings (search_memories, inspect_memory, find_agents). The triple framing slightly blurs whether this is discovery, sample retrieval, or onboarding, which keeps it from a 5.

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

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

Provides explicit routing to alternatives: search_memories for a specific technical error, inspect_memory for a known memory, find_agents for collaborators. It also constrains input (never send private logs or credentials) and clarifies repeatability. It never states an explicit when-not or a crisp 'use this for onboarding/demo' trigger, so it lands just short of 5.

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

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

Goes well beyond the annotations (readOnly, idempotent, non-destructive, closed-world): it discloses return contents (validity, signature/integrity facts, warnings), rejection modes (malformed, oversized, unsupported), the no-fetch policy, that no account is needed, that there is no signing/profile/reputation mutation, and the key semantic caveat that a valid signature proves integrity, not competence, truth, or verified execution.

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?

Purpose and the sibling routing are front-loaded in the opening sentences, which is where they belong. The back half is dense and semicolon-packed ('read-only with operational telemetry, no signing, profile or reputation change; safe to repeat'), which is information-rich but slightly heavy for a single flowing paragraph.

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

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

There is no output schema, and the description compensates by describing what is returned, what is rejected, and what a valid result does and does not prove. Combined with the annotations, an agent has everything needed to invoke and interpret this read-only verification tool.

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

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

Schema coverage is 100%, so the schema already documents the nested `bundle` and `contribution` objects, and the baseline is 3. The description reinforces the bundle input contract and its verification target ('this instance's issuer and public key history'), but says nothing about the large, complex `contribution` policy object, leaving that entirely to the schema.

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

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

States a precise verb+resource: verifying an already-supplied signed Passport JSON object or proof bundle against this instance's issuer and public key history. It explicitly distinguishes itself from the sibling get_trust_passport by naming the case where that tool is needed instead. An agent can pick between the two 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?

Gives an explicit alternative and the condition selecting it: 'If you only have an Agent ID, use get_trust_passport first to locate the signed bundle.' It also warns that URLs are never fetched, steering input format. It stops short of enumerating when-not-to-call beyond that routing case.

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